home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 3 / CD ACTUAL 3.iso / linux / system / bsvc-1.000 / bsvc-1 / bsvc-1.0.4 / src / Sim68000 / cpu / exec.cxx < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-26  |  145.3 KB  |  5,482 lines
  1. //////////////////////////////////////////////////////////////////////////////
  2. // $Id: exec.cxx,v 1.9 1995/07/26 20:30:39 bmott Exp $
  3. //////////////////////////////////////////////////////////////////////////////
  4. // exec.cxx 
  5. //
  6. // Functions to simulate 68000 instruction execution
  7. // 
  8. // Sim68000 "Motorola 68000 Simulator"
  9. // Copyright (c) 1993
  10. // By: Bradford W. Mott
  11. // November 4,1993
  12. //
  13. ///////////////////////////////////////////////////////////////////////////////
  14. // $Log: exec.cxx,v $
  15. // Revision 1.9  1995/07/26  20:30:39  bmott
  16. // ADDA, CMPA, LEA, LINK, SUBA, and UNLK were not accessing the correct
  17. // stack pointer when the processor was in supervisor mode
  18. //
  19. // Revision 1.8  1995/07/03  19:01:38  bmott
  20. // Fixed bug in DIVS instruction that was introduced by the last version.
  21. //
  22. // Revision 1.7  1995/06/29  23:15:16  bmott
  23. // Fixed bug in the DIVS instruction, fixed post-increment and pre-decrement
  24. // bug in the Bit instructions
  25. //
  26. // Revision 1.6  1995/02/18  19:20:00  bmott
  27. // Added code to handle the SUBX instruction, fixed addressing mode bug
  28. // in the CMPM instruction, fixed stack pointer bug in the RTR instruction
  29. //
  30. // Revision 1.5  1995/02/11  03:28:14  bmott
  31. // Fixed condition code bug in the CMP and CMPA instructions
  32. //
  33. // Revision 1.4  1995/01/13  00:33:26  bmott
  34. // Change the in_register argument for the ComputeEffectiveAddress
  35. // member function
  36. //
  37. // Revision 1.3  1995/01/01  05:29:45  bmott
  38. // Fixed bug in the RTS instruction and added code to handle the STOP
  39. // instruction.
  40. //
  41. // Revision 1.2  1994/09/22  00:11:56  bmott
  42. // Added method to execute BREAK instruction
  43. //
  44. // Revision 1.1  1994/02/18  20:04:12  bmott
  45. // Initial revision
  46. //
  47. ///////////////////////////////////////////////////////////////////////////////
  48.  
  49. #include "m68000.hxx"
  50. #include "Tools.hxx"
  51.  
  52. ///////////////////////////////////////////////////////////////////////////////
  53. // Compute the effective address, given the mode and register bits
  54. ///////////////////////////////////////////////////////////////////////////////
  55. int m68000::ComputeEffectiveAddress(unsigned long& address,
  56.                                     int& in_register,
  57.                                     String& description,
  58.                                     int mode_register,
  59.                                     int size, int trace)
  60. {
  61.   unsigned long tmp;
  62.   unsigned int extend_word;
  63.   int status;
  64.  
  65.   switch (mode_register>>3)
  66.   {
  67.     case 0:  // Data Register Direct
  68.       address=(mode_register & 0x7) + D0_INDEX;
  69.       if(trace)
  70.       {
  71.         description+=register_data[address].name;
  72.       }
  73.       in_register=1;
  74.       return(EXECUTE_OK);
  75.       break;
  76.  
  77.     case 1:  // Address Register Direct
  78.       address=(mode_register & 0x7);
  79.       if((address==7) && (register_value[SR_INDEX] & S_FLAG))
  80.         address=SSP_INDEX;
  81.       else
  82.         address+=A0_INDEX;
  83.       if(trace)
  84.       {
  85.         description+=register_data[address].name;
  86.       }
  87.       in_register=1;
  88.       return(EXECUTE_OK);
  89.       break;
  90.  
  91.     case 2:  // Address Register Indirect
  92.       tmp=(mode_register & 0x7);
  93.       if((tmp==7) && (register_value[SR_INDEX] & S_FLAG))
  94.         tmp=SSP_INDEX;
  95.       else
  96.         tmp+=A0_INDEX;
  97.       address=register_value[tmp];
  98.       if(trace)
  99.       {
  100.         description+="(";
  101.         description+=register_data[tmp].name;
  102.         description+=")";
  103.       }
  104.       in_register=0;
  105.       return(EXECUTE_OK);
  106.       break;
  107.        
  108.     case 3:  // Address Register Indirect with Post-Increment
  109.       tmp=(mode_register & 0x7);
  110.       if((tmp==7) && (register_value[SR_INDEX] & S_FLAG))
  111.         tmp=SSP_INDEX;
  112.       else
  113.         tmp+=A0_INDEX;
  114.       address=register_value[tmp];
  115.       switch (size)
  116.       {
  117.         case BYTE:
  118.           register_value[tmp]+=1;
  119.           break;
  120.         case WORD:
  121.           register_value[tmp]+=2;
  122.           break;
  123.         case LONG:
  124.           register_value[tmp]+=4;
  125.           break;
  126.       }
  127.       if(trace)
  128.       {
  129.         description+="(";
  130.         description+=register_data[tmp].name;
  131.         description+=")+";
  132.       }
  133.       in_register=0;
  134.       return(EXECUTE_OK);
  135.       break;
  136.  
  137.     case 4:  // Address Register Indirect with Pre-Decrement 
  138.       tmp=(mode_register & 0x7);
  139.       if((tmp==7) && (register_value[SR_INDEX] & S_FLAG))
  140.         tmp=SSP_INDEX;
  141.       else
  142.         tmp+=A0_INDEX;
  143.       switch (size)
  144.       {
  145.         case BYTE:
  146.           register_value[tmp]-=1;
  147.           break;
  148.         case WORD:
  149.           register_value[tmp]-=2;
  150.           break;
  151.         case LONG:
  152.           register_value[tmp]-=4;
  153.           break;
  154.       }
  155.       address=register_value[tmp];
  156.       if(trace)
  157.       {
  158.         description+="-(";
  159.         description+=register_data[tmp].name;
  160.         description+=")";
  161.       }
  162.       in_register=0;
  163.       return(EXECUTE_OK);
  164.       break;
  165.  
  166.     case 5:  // Address Register Indirect with Displacement
  167.       tmp=(mode_register & 0x7);
  168.       if((tmp==7) && (register_value[SR_INDEX] & S_FLAG))
  169.         tmp=SSP_INDEX;
  170.       else
  171.         tmp+=A0_INDEX;
  172.       address=register_value[tmp];
  173.  
  174.       if((status=Peek(register_value[PC_INDEX],extend_word,WORD))!=EXECUTE_OK)
  175.       {
  176.         register_value[PC_INDEX]+=2;
  177.         return(status);
  178.       } 
  179.       else
  180.       {
  181.         register_value[PC_INDEX]+=2;
  182.       } 
  183.  
  184.       address+=SignExtend(extend_word,WORD);
  185.       if(trace)
  186.       {
  187.         description+="($";
  188.         description+=IntToString(extend_word,4);
  189.         description+=",";
  190.         description+=register_data[tmp].name;
  191.         description+=")";
  192.       }
  193.       in_register=0;
  194.       return(EXECUTE_OK);
  195.       break;
  196.  
  197.     case 6:  // Address Register Indirect with Index and 8-bit Displacement
  198.       tmp=(mode_register & 0x7);
  199.       if((tmp==7) && (register_value[SR_INDEX] & S_FLAG))
  200.         tmp=SSP_INDEX;
  201.       else
  202.         tmp+=A0_INDEX;
  203.       address=register_value[tmp];
  204.  
  205.       if((status=Peek(register_value[PC_INDEX],extend_word,WORD))!=EXECUTE_OK)
  206.       {
  207.         register_value[PC_INDEX]+=2;
  208.         return(status);
  209.       } 
  210.       else
  211.       {
  212.         register_value[PC_INDEX]+=2;
  213.       } 
  214.  
  215.       address+=SignExtend(extend_word&0xff,BYTE);     // Add 8-bit displacement
  216.       if(trace)
  217.       {
  218.         description+="$";
  219.         description+=IntToString(extend_word&0xff,2);
  220.         description+="(";
  221.         description+=register_data[tmp].name;
  222.         description+=",";
  223.       }
  224.        
  225.       if(extend_word & 0x8000)                        // Get register number
  226.       {
  227.         tmp=((extend_word >> 12) & 0x7);
  228.         if((tmp==7) && (register_value[SR_INDEX] & S_FLAG))
  229.           tmp=SSP_INDEX;
  230.         else
  231.           tmp+=A0_INDEX;
  232.       }
  233.       else
  234.       {
  235.         tmp=((extend_word >> 12) & 0x7) + D0_INDEX;
  236.       }
  237.  
  238.       if(extend_word & 0x0800)
  239.         address+=register_value[tmp];
  240.       else
  241.         address+=SignExtend(register_value[tmp],WORD);
  242.  
  243.       if(trace)
  244.       {
  245.         description+=register_data[tmp].name;
  246.         if(extend_word & 0x0800)
  247.           description+=".L)";
  248.         else
  249.           description+=".W)";
  250.       }
  251.       in_register=0;
  252.       return(EXECUTE_OK);
  253.       break;
  254.  
  255.     case 7:
  256.       switch (mode_register & 7)
  257.       {
  258.         case 0:  // Absolute Short Address
  259.           if((status=Peek(register_value[PC_INDEX],extend_word,WORD))
  260.               != EXECUTE_OK)
  261.           {
  262.             register_value[PC_INDEX]+=2;
  263.             return(status);
  264.           } 
  265.           else
  266.           {
  267.             register_value[PC_INDEX]+=2;
  268.           } 
  269.           address=SignExtend(extend_word,WORD);
  270.           if(trace)
  271.           {
  272.             description+=IntToString(extend_word,4);
  273.             description+=".W";
  274.           }
  275.           in_register=0;
  276.           return(EXECUTE_OK);
  277.           break;
  278.  
  279.         case 1:  // Absolute Long Address
  280.           if((status=Peek(register_value[PC_INDEX],extend_word,LONG))
  281.               != EXECUTE_OK)
  282.           {
  283.             register_value[PC_INDEX]+=4;
  284.             return(status);
  285.           } 
  286.           else
  287.           {
  288.             register_value[PC_INDEX]+=4;
  289.           } 
  290.           address=extend_word;
  291.           if(trace)
  292.           {
  293.             description+=IntToString(extend_word,8);
  294.             description+=".L";
  295.           }
  296.           in_register=0;
  297.           return(EXECUTE_OK);
  298.           break;
  299.  
  300.         case 2:  // Program Counter with Displacement
  301.           address=register_value[PC_INDEX];
  302.           if((status=Peek(register_value[PC_INDEX],extend_word,WORD))
  303.               != EXECUTE_OK)
  304.           {
  305.             register_value[PC_INDEX]+=2;
  306.             return(status);
  307.           } 
  308.           else
  309.           {
  310.             register_value[PC_INDEX]+=2;
  311.           }
  312.           address+=SignExtend(extend_word,WORD);
  313.           if(trace)
  314.           {
  315.             description+="($";
  316.             description+=IntToString(extend_word,4);
  317.             description+=",PC)";
  318.           }
  319.           in_register=0;
  320.           return(EXECUTE_OK);
  321.           break;
  322.  
  323.         case 3:  // Program Counter with Index and 8-bit Displacement
  324.           address=register_value[PC_INDEX];
  325.           if((status=Peek(register_value[PC_INDEX],extend_word,WORD))
  326.               != EXECUTE_OK)
  327.           {
  328.             register_value[PC_INDEX]+=2;
  329.             return(status);
  330.           } 
  331.           else
  332.           {
  333.             register_value[PC_INDEX]+=2;
  334.           }
  335.  
  336.           address+=SignExtend(extend_word & 0xff,BYTE);  // 8-bit displacement
  337.           if(trace)
  338.           {
  339.             description+="$";
  340.             description+=IntToString(extend_word & 0xff,2);
  341.             description+="(PC,";
  342.           }
  343.  
  344.           if(extend_word & 0x8000)                       // Get register number
  345.           {
  346.             tmp=((extend_word >> 12) & 0x7);
  347.             if((tmp==7) && (register_value[SR_INDEX] & S_FLAG))
  348.               tmp=SSP_INDEX;
  349.             else
  350.               tmp+=A0_INDEX;
  351.           }
  352.           else
  353.           {
  354.             tmp=((extend_word >> 12) & 0x7) + D0_INDEX;
  355.           }
  356.  
  357.           if(extend_word & 0x0800)
  358.             address+=register_value[tmp];
  359.           else
  360.             address+=SignExtend(register_value[tmp],WORD);
  361.  
  362.           if(trace)
  363.           {
  364.             description+=register_data[tmp].name;
  365.             if(extend_word & 0x0800)
  366.               description+=".L)";
  367.             else
  368.               description+=".W)";
  369.           }
  370.           in_register=0;
  371.           return(EXECUTE_OK);
  372.           break;
  373.  
  374.         case 4:  // Immediate Data
  375.           address = register_value[PC_INDEX];
  376.  
  377.           if(size == BYTE)
  378.             ++address;
  379.  
  380.           if((size == BYTE) || (size == WORD))
  381.             register_value[PC_INDEX]+=2;
  382.           else
  383.             register_value[PC_INDEX]+=4;
  384.  
  385.           if(trace)
  386.           {
  387.             // Fetch the immediate data
  388.             if((status=Peek(address, extend_word, size)) != EXECUTE_OK)
  389.               return(status);
  390.  
  391.             description+="#$";
  392.             if(size==BYTE)
  393.               description+=IntToString(extend_word,2);
  394.             else if(size==WORD)
  395.               description+=IntToString(extend_word,4);
  396.             else if(size==LONG)
  397.               description+=IntToString(extend_word,8);
  398.           }
  399.           in_register=0;
  400.           return(EXECUTE_OK);
  401.           break;
  402.       }
  403.   } 
  404.   return(EXECUTE_ILLEGAL_INSTRUCTION);
  405. }
  406.  
  407. ///////////////////////////////////////////////////////////////////////////////
  408. // Sign extend the value
  409. ///////////////////////////////////////////////////////////////////////////////
  410. unsigned int m68000::SignExtend(unsigned int value, int size)
  411. {
  412.   switch (size) 
  413.   {
  414.     case BYTE:
  415.       if(value & 0x80)
  416.         return((value & 0xff) | 0xffffff00);
  417.       else
  418.         return(value & 0xff);
  419.       break;
  420.  
  421.     case WORD:
  422.       if(value & 0x8000)
  423.         return((value & 0xffff) | 0xffff0000);
  424.       else
  425.         return(value & 0xffff);
  426.       break;
  427.  
  428.     default:  // LONG
  429.       return(value & 0xffffffff);
  430.       break;
  431.   }
  432. }
  433.  
  434. ///////////////////////////////////////////////////////////////////////////////
  435. // Read a BYTE, WORD, or LONG from memory
  436. ///////////////////////////////////////////////////////////////////////////////
  437. int m68000::Peek(unsigned long address, unsigned int& value, int size)
  438. {
  439.   unsigned char c1,c2,c3,c4;
  440.  
  441.   switch (size)
  442.   {
  443.     case BYTE:
  444.       if(address_space->Peek(address,c1))
  445.       {
  446.         value=(unsigned int)c1;
  447.         return(EXECUTE_OK);
  448.       }
  449.       else
  450.       {
  451.         return(EXECUTE_BUS_ERROR);
  452.       }
  453.       break;
  454.  
  455.     case WORD:
  456.       if((address&1)==0)
  457.       { 
  458.         if(address_space->Peek(address,c1) && address_space->Peek(address+1,c2))
  459.         {
  460.           value = (((unsigned int)c1)<<8) | ((unsigned int)c2);
  461.           return(EXECUTE_OK);
  462.         }
  463.         else
  464.         {
  465.           return(EXECUTE_BUS_ERROR);
  466.         }
  467.       }
  468.       else
  469.       {
  470.         return(EXECUTE_ADDRESS_ERROR); 
  471.       }
  472.       break;
  473.  
  474.     default:  // LONG
  475.       if((address&1)==0)
  476.       {
  477.         if(address_space->Peek(address,c1) && address_space->Peek(address+1,c2)
  478.            && address_space->Peek(address+2,c3)
  479.            && address_space->Peek(address+3,c4))
  480.         {
  481.           value = (((unsigned int)c1)<<24) | (((unsigned int)c2)<<16) |
  482.                   (((unsigned int)c3)<<8) | ((unsigned int)c4);
  483.           return(EXECUTE_OK);
  484.         }
  485.         else
  486.         {
  487.           return(EXECUTE_BUS_ERROR);
  488.         }
  489.       }
  490.       else
  491.       {
  492.         return(EXECUTE_ADDRESS_ERROR);
  493.       }
  494.       break;
  495.   }
  496. }
  497.  
  498. ///////////////////////////////////////////////////////////////////////////////
  499. // Write a BYTE, WORD, or LONG to memory
  500. ///////////////////////////////////////////////////////////////////////////////
  501. int m68000::Poke(unsigned long address, unsigned int value, int size)
  502. {
  503.   switch (size)
  504.   {
  505.     case BYTE:
  506.       if(address_space->Poke(address,(unsigned char)value))
  507.       {
  508.         return(EXECUTE_OK);
  509.       }
  510.       else
  511.       {
  512.         return(EXECUTE_BUS_ERROR);
  513.       }
  514.       break;
  515.  
  516.     case WORD:
  517.       if((address&1)==0)
  518.       { 
  519.         if(address_space->Poke(address+1,(unsigned char)value) &&
  520.            address_space->Poke(address,(unsigned char)(value>>8)))
  521.         {
  522.           return(EXECUTE_OK);
  523.         }
  524.         else
  525.         {
  526.           return(EXECUTE_BUS_ERROR);
  527.         }
  528.       }
  529.       else
  530.       {
  531.         return(EXECUTE_ADDRESS_ERROR); 
  532.       }
  533.       break;
  534.  
  535.     default:  // LONG
  536.       if((address&1)==0)
  537.       {
  538.         if(address_space->Poke(address+3,(unsigned char)value) &&
  539.            address_space->Poke(address+2,(unsigned char)(value>>8)) &&
  540.            address_space->Poke(address+1,(unsigned char)(value>>16)) &&
  541.            address_space->Poke(address,(unsigned char)(value>>24)))
  542.         {
  543.           return(EXECUTE_OK);
  544.         }
  545.         else
  546.         {
  547.           return(EXECUTE_BUS_ERROR);
  548.         }
  549.       }
  550.       else
  551.       {
  552.         return(EXECUTE_ADDRESS_ERROR);
  553.       }
  554.       break;
  555.   }
  556. }
  557.  
  558. ///////////////////////////////////////////////////////////////////////////////
  559. // Clear the condition codes in the status register given by the mask
  560. ///////////////////////////////////////////////////////////////////////////////
  561. void m68000::ClearConditionCodes(int mask)
  562. {
  563.   if(mask&C_FLAG)
  564.     register_value[SR_INDEX] &= ~C_FLAG;
  565.   else if(mask&V_FLAG)
  566.     register_value[SR_INDEX] &= ~V_FLAG;
  567.   else if(mask&Z_FLAG)
  568.     register_value[SR_INDEX] &= ~Z_FLAG;
  569.   else if(mask&N_FLAG)
  570.     register_value[SR_INDEX] &= ~N_FLAG;
  571.   else if(mask&X_FLAG)
  572.     register_value[SR_INDEX] &= ~X_FLAG;
  573.   else if(mask&T_FLAG)
  574.     register_value[SR_INDEX] &= ~T_FLAG;
  575.   else if(mask&S_FLAG)
  576.     register_value[SR_INDEX] &= ~S_FLAG;
  577. }
  578.  
  579. ///////////////////////////////////////////////////////////////////////////////
  580. // Set the condition codes in the status register
  581. ///////////////////////////////////////////////////////////////////////////////
  582. void m68000::SetConditionCodes(unsigned int src, unsigned int dest,
  583.                                unsigned int result, int size,
  584.                                int operation, int mask)
  585. {
  586.   int S,D,R;
  587.  
  588.   switch (size) {
  589.     case BYTE: 
  590.       S = (src >> 7) & 1;
  591.       D = (dest >> 7) & 1;
  592.       R = (result >> 7) & 1;
  593.       result = result & 0xff;
  594.       break;
  595.     case WORD: 
  596.       S = (src >> 15) & 1;
  597.       D = (dest >> 15) & 1;
  598.       R = (result >> 15) & 1;
  599.       result = result & 0xffff;
  600.       break;
  601.     case LONG: 
  602.       S = (src >> 31) & 1;
  603.       D = (dest >> 31) & 1;
  604.       R = (result >> 31) & 1;
  605.       result = result & 0xffffffff;
  606.       break;
  607.    }
  608.  
  609.   if(mask&C_FLAG)
  610.   {
  611.     if (operation==ADDITION)
  612.     {
  613.       if((S && D) || (!R && D) || (S && !R))
  614.         register_value[SR_INDEX] |= C_FLAG;
  615.       else
  616.         register_value[SR_INDEX] &= ~C_FLAG;
  617.     }
  618.     else if (operation==SUBTRACTION)
  619.     {
  620.       if((S && !D) || (R && !D) || (S && R))
  621.         register_value[SR_INDEX] |= C_FLAG;
  622.       else
  623.         register_value[SR_INDEX] &= ~C_FLAG;
  624.     }
  625.     else
  626.     {
  627.       register_value[SR_INDEX] &= ~C_FLAG;
  628.     }
  629.   }
  630.  
  631.   if(mask&V_FLAG)
  632.   {
  633.     if (operation==ADDITION)
  634.     {
  635.       if((S && D && !R) || (!S && !D && R))
  636.         register_value[SR_INDEX] |= V_FLAG;
  637.       else
  638.         register_value[SR_INDEX] &= ~V_FLAG;
  639.     }
  640.     else if (operation==SUBTRACTION)
  641.     {
  642.       if((!S && D && !R) || (S && !D && R))
  643.         register_value[SR_INDEX] |= V_FLAG;
  644.       else
  645.         register_value[SR_INDEX] &= ~V_FLAG;
  646.     }
  647.     else
  648.     {
  649.       register_value[SR_INDEX] &= ~V_FLAG;
  650.     }
  651.   }
  652.  
  653.   if(mask&Z_FLAG)
  654.   {
  655.     if(!result)
  656.       register_value[SR_INDEX] |= Z_FLAG;
  657.     else
  658.       register_value[SR_INDEX] &= ~Z_FLAG;
  659.   }
  660.  
  661.   if(mask&N_FLAG)
  662.   {
  663.     if(R)
  664.       register_value[SR_INDEX] |= N_FLAG;
  665.     else
  666.       register_value[SR_INDEX] &= ~N_FLAG;
  667.   }
  668.  
  669.   if(mask&X_FLAG)
  670.   {
  671.     if (operation==ADDITION)
  672.     {
  673.       if((S && D) || (!R && D) || (S && !R))
  674.         register_value[SR_INDEX] |= X_FLAG;
  675.       else
  676.         register_value[SR_INDEX] &= ~X_FLAG;
  677.     }
  678.     else if (operation==SUBTRACTION)
  679.     {
  680.       if((S && !D) || (R && !D) || (S && R))
  681.         register_value[SR_INDEX] |= X_FLAG;
  682.       else
  683.         register_value[SR_INDEX] &= ~X_FLAG;
  684.     }
  685.     else
  686.     {
  687.       register_value[SR_INDEX] &= ~X_FLAG;
  688.     }
  689.   }
  690. }
  691.  
  692. ///////////////////////////////////////////////////////////////////////////////
  693. // Set the regiter to the given value 
  694. ///////////////////////////////////////////////////////////////////////////////
  695. void m68000::SetRegister(int register_number, unsigned int value, int size)
  696. {
  697.   switch (size)
  698.   {
  699.     case BYTE:
  700.       register_value[register_number] &= 0xffffff00;
  701.       register_value[register_number] |= (value&0xff);
  702.       break;
  703.     case WORD:
  704.       register_value[register_number] &= 0xffff0000;
  705.       register_value[register_number] |= (value&0xffff);
  706.       break;
  707.     case LONG:
  708.       register_value[register_number] &= 0x00000000;
  709.       register_value[register_number] |= (value&0xffffffff);
  710.       break;
  711.    } 
  712. }
  713.  
  714. ///////////////////////////////////////////////////////////////////////////////
  715. // Checks the condition codes to see if a branch should occur
  716. ///////////////////////////////////////////////////////////////////////////////
  717. int m68000::CheckConditionCodes(int code, String& mnemonic, int trace)
  718. {
  719.   int branch=0;
  720.   unsigned long sr;
  721.  
  722.   sr=register_value[SR_INDEX];
  723.   switch (code)
  724.   {
  725.     case 4:
  726.       branch=!(sr&C_FLAG); 
  727.       if(trace) mnemonic+="CC";
  728.       break; 
  729.     case 5: 
  730.       branch=(sr&C_FLAG); 
  731.       if(trace) mnemonic+="CS";
  732.       break; 
  733.     case 7:
  734.       branch=(sr&Z_FLAG); 
  735.       if(trace) mnemonic+="EQ";
  736.       break; 
  737.     case 1:
  738.       branch=0;
  739.       if(trace) mnemonic+="F";
  740.       break;
  741.     case 12:
  742.       branch=((sr&N_FLAG) && (sr&V_FLAG)) || (!(sr&N_FLAG) && !(sr&V_FLAG)); 
  743.       if(trace) mnemonic+="GE";
  744.       break; 
  745.     case 14:
  746.       branch=((sr&N_FLAG) && (sr&V_FLAG) && !(sr&Z_FLAG)) ||
  747.              (!(sr&N_FLAG) && !(sr&V_FLAG) && !(sr&Z_FLAG)); 
  748.       if(trace) mnemonic+="GT";
  749.       break; 
  750.     case 2:
  751.       branch=(!(sr&C_FLAG) && !(sr&Z_FLAG)); 
  752.       if(trace) mnemonic+="HI";
  753.       break; 
  754.     case 15:
  755.       branch=(sr&Z_FLAG) || ((sr&N_FLAG) && !(sr&V_FLAG)) ||
  756.              (!(sr&N_FLAG) && (sr&V_FLAG)); 
  757.       if(trace) mnemonic+="LE";
  758.       break; 
  759.     case 3:
  760.       branch=(sr&C_FLAG) || (sr&Z_FLAG);
  761.       if(trace) mnemonic+="LS";
  762.       break; 
  763.     case 13:
  764.       branch=((sr&N_FLAG) && !(sr&V_FLAG)) || (!(sr&N_FLAG) && (sr&V_FLAG)); 
  765.       if(trace) mnemonic+="LT";
  766.       break; 
  767.     case 11:
  768.       branch=(sr&N_FLAG);
  769.       if(trace) mnemonic+="MI";
  770.       break; 
  771.     case 6:
  772.       branch=!(sr&Z_FLAG);
  773.       if(trace) mnemonic+="NE";
  774.       break; 
  775.     case 10:
  776.       branch=!(sr&N_FLAG);
  777.       if(trace) mnemonic+="PL";
  778.       break; 
  779.     case 0:
  780.       branch=1;
  781.       if(trace) mnemonic+="T";
  782.       break;
  783.     case 8:
  784.       branch=!(sr&V_FLAG);
  785.       if(trace) mnemonic+="VC";
  786.       break; 
  787.     case 9:
  788.       branch=(sr&V_FLAG);
  789.       if(trace) mnemonic+="VS";
  790.       break; 
  791.   } 
  792.   return(branch);
  793. }
  794.  
  795.  
  796. ///////////////////////////////////////////////////////////////////////////////
  797. // Execute the '' instruction 
  798. ///////////////////////////////////////////////////////////////////////////////
  799. int m68000::ExecuteABCD(int opcode, String& trace_record, int trace)
  800. {
  801.   return(ExecuteInvalid(opcode, trace_record, trace));
  802. }
  803.  
  804. ///////////////////////////////////////////////////////////////////////////////
  805. // Execute the 'ADD' instruction 
  806. ///////////////////////////////////////////////////////////////////////////////
  807. int m68000::ExecuteADD(int opcode, String& trace_record, int trace)
  808. {
  809.   int status, size, in_register_flag;
  810.   unsigned long ea_address, register_number;
  811.   unsigned int result, ea_data;
  812.   String mnemonic, ea_description;
  813.  
  814.   size=(opcode&0x00c0) >> 6;
  815.  
  816.   // Get the <ea> data address
  817.   if((status=ComputeEffectiveAddress(ea_address, in_register_flag,
  818.                   ea_description, opcode & 0x3f, size, trace)) != EXECUTE_OK)
  819.   { return(status); }
  820.  
  821.   // Fetch the <ea> data 
  822.   if (in_register_flag)
  823.     ea_data=register_value[ea_address];
  824.   else
  825.     if ((status=Peek(ea_address, ea_data, size)) != EXECUTE_OK)
  826.       return(status);
  827.  
  828.   // Get the register number
  829.   register_number=D0_INDEX+((opcode&0x0e00) >> 9);
  830.  
  831.   if(trace)
  832.   {
  833.     mnemonic+="{Mnemonic {ADD";
  834.     if (size==BYTE)
  835.       mnemonic+=".B ";
  836.     else if (size==WORD)
  837.       mnemonic+=".W ";
  838.     else if (size==LONG)
  839.       mnemonic+=".L ";
  840.   }
  841.  
  842.   if(opcode & 0x0100)    // <Dn> + <ea> -> <ea>
  843.   {
  844.     if(trace)
  845.     {
  846.       mnemonic+=register_data[register_number].name;
  847.       mnemonic+=",";
  848.       mnemonic+=ea_description;
  849.     }
  850.     result=register_value[register_number]+ea_data;
  851.     SetConditionCodes(register_value[register_number], ea_data, result, size,
  852.                       ADDITION, C_FLAG|V_FLAG|Z_FLAG|N_FLAG|X_FLAG);
  853.     if((status=Poke(ea_address, result, size)) != EXECUTE_OK)
  854.       return(status);
  855.   }
  856.   else                   // <ea> + <Dn> -> <Dn>
  857.   {
  858.     if(trace)
  859.     {
  860.       mnemonic+=ea_description;
  861.       mnemonic+=",";
  862.       mnemonic+=register_data[register_number].name;
  863.     }
  864.     result=ea_data+register_value[register_number];
  865.     SetConditionCodes(ea_data, register_value[register_number], result, size,
  866.                       ADDITION, C_FLAG|V_FLAG|Z_FLAG|N_FLAG|X_FLAG);
  867.     SetRegister(register_number, result, size);
  868.   }
  869.  
  870.   if(trace)
  871.   {
  872.     mnemonic+="}} ";
  873.     trace_record+=mnemonic;
  874.   }
  875.   return(EXECUTE_OK);
  876. }
  877.  
  878. ///////////////////////////////////////////////////////////////////////////////
  879. // Execute the 'ADDA' instruction 
  880. ///////////////////////////////////////////////////////////////////////////////
  881. int m68000::ExecuteADDA(int opcode, String& trace_record, int trace)
  882. { 
  883.   int status, size, in_register_flag;
  884.   unsigned long ea_address, register_number;
  885.   unsigned int result, ea_data;
  886.   String mnemonic, ea_description;
  887.  
  888.   if (opcode&0x0100)
  889.     size=LONG;
  890.   else
  891.     size=WORD;
  892.  
  893.   // Get the <ea> data address
  894.   if((status=ComputeEffectiveAddress(ea_address, in_register_flag,
  895.                   ea_description, opcode & 0x3f, size, trace)) != EXECUTE_OK)
  896.   { return(status); }
  897.  
  898.   // Fetch the <ea> data 
  899.   if (in_register_flag)
  900.     ea_data=register_value[ea_address];
  901.   else
  902.     if ((status=Peek(ea_address, ea_data, size)) != EXECUTE_OK)
  903.       return(status);
  904.  
  905.   if(size==WORD)
  906.     ea_data=SignExtend(ea_data,WORD);
  907.  
  908.   // Get the register number
  909.   register_number=A0_INDEX+((opcode&0x0e00) >> 9);
  910.  
  911.   // Adjust register_number if it's A7 and we're in supervisor mode
  912.   if((register_number == USP_INDEX) && (register_value[SR_INDEX] & S_FLAG))
  913.     register_number = SSP_INDEX;
  914.  
  915.   result=ea_data+register_value[register_number];
  916.   SetRegister(register_number, result, LONG);
  917.  
  918.   if(trace)
  919.   {
  920.     mnemonic+="{Mnemonic {ADDA";
  921.     if (size==WORD)
  922.       mnemonic+=".W ";
  923.     else if (size==LONG)
  924.       mnemonic+=".L ";
  925.  
  926.     mnemonic+=ea_description;
  927.     mnemonic+=",";
  928.     mnemonic+=register_data[register_number].name;
  929.     mnemonic+="}} ";
  930.     trace_record+=mnemonic;
  931.   }
  932.   return(EXECUTE_OK);
  933. }
  934.  
  935. ///////////////////////////////////////////////////////////////////////////////
  936. // Execute the 'ADDI' instruction 
  937. ///////////////////////////////////////////////////////////////////////////////
  938. int m68000::ExecuteADDI(int opcode, String& trace_record, int trace)
  939. {
  940.   int status, size, in_register;
  941.   unsigned long dest_addr, src_addr;
  942.   unsigned int result, src, dest;
  943.   String mnemonic;
  944.  
  945.   size=(opcode&0x00c0) >> 6;
  946.  
  947.   if(trace)
  948.   {
  949.     mnemonic+="{Mnemonic {ADDI";
  950.     if (size==BYTE)
  951.       mnemonic+=".B ";
  952.     else if (size==WORD)
  953.       mnemonic+=".W ";
  954.     else if (size==LONG)
  955.       mnemonic+=".L ";
  956.   }
  957.  
  958.   // Get the immediate data pointer
  959.   if((status=ComputeEffectiveAddress(src_addr, in_register, mnemonic,
  960.                     0x3c, size, trace)) != EXECUTE_OK)
  961.   { return(status); }
  962.  
  963.   // Fetch the immediate data
  964.   if((status=Peek(src_addr, src, size)) != EXECUTE_OK)
  965.     return(status);
  966.  
  967.   if(trace)
  968.     mnemonic+=",";
  969.  
  970.   // Get the destination data pointer
  971.   if((status=ComputeEffectiveAddress(dest_addr, in_register, mnemonic,
  972.                     opcode & 0x3f, size, trace)) != EXECUTE_OK)
  973.   {
  974.     return(status);
  975.   }
  976.  
  977.   if(in_register)
  978.   {
  979.     dest=register_value[dest_addr];
  980.     result=dest+src;
  981.     SetConditionCodes(src,dest,result,size,
  982.                       ADDITION, C_FLAG|V_FLAG|Z_FLAG|N_FLAG|X_FLAG);
  983.     SetRegister(dest_addr,result,size);
  984.   } 
  985.   else
  986.   {
  987.     if((status=Peek(dest_addr, dest, size)) != EXECUTE_OK)
  988.       return(status);
  989.     result=dest+src;
  990.     SetConditionCodes(src,dest,result,size,
  991.                       ADDITION, C_FLAG|V_FLAG|Z_FLAG|N_FLAG|X_FLAG);
  992.     if((status=Poke(dest_addr, result, size)) != EXECUTE_OK)
  993.       return(status);
  994.   }
  995.  
  996.   if (trace)
  997.   {
  998.     mnemonic+="}} ";
  999.     trace_record+=mnemonic;
  1000.   }
  1001.   return(EXECUTE_OK);
  1002. }
  1003.  
  1004. ///////////////////////////////////////////////////////////////////////////////
  1005. // Execute the 'ADDQ' instruction 
  1006. ///////////////////////////////////////////////////////////////////////////////
  1007. int m68000::ExecuteADDQ(int opcode, String& trace_record, int trace)
  1008. {
  1009.   int status, size, in_register_flag;
  1010.   unsigned long ea_address, immediate_data;
  1011.   unsigned int result, ea_data;
  1012.   String ea_description;
  1013.  
  1014.   size=(opcode&0x00c0) >> 6;
  1015.  
  1016.   // Get the immediate data out of the opcode
  1017.   if((immediate_data=(opcode&0x0e00) >> 9) == 0)
  1018.     immediate_data=8;
  1019.  
  1020.   // Get the <ea> data address
  1021.   if((status=ComputeEffectiveAddress(ea_address, in_register_flag,
  1022.                   ea_description, opcode & 0x3f, size, trace)) != EXECUTE_OK)
  1023.   { return(status); }
  1024.  
  1025.   // Fetch the <ea> data 
  1026.   if(in_register_flag)
  1027.     ea_data=register_value[ea_address];
  1028.   else
  1029.     if((status=Peek(ea_address, ea_data, size)) != EXECUTE_OK)
  1030.       return(status);
  1031.  
  1032.   if(in_register_flag)
  1033.   {
  1034.     result=immediate_data+ea_data;
  1035.     if((ea_address>=A0_INDEX) && (ea_address<=SSP_INDEX))
  1036.     {
  1037.       SetRegister(ea_address, result, LONG);
  1038.     }
  1039.     else
  1040.     {
  1041.       SetConditionCodes(immediate_data, ea_data, result, size,
  1042.                         ADDITION, C_FLAG|V_FLAG|Z_FLAG|N_FLAG|X_FLAG);
  1043.       SetRegister(ea_address, result, size);
  1044.     }
  1045.   }
  1046.   else
  1047.   {
  1048.     result=immediate_data+ea_data;
  1049.     SetConditionCodes(immediate_data, ea_data, result, size,
  1050.                       ADDITION, C_FLAG|V_FLAG|Z_FLAG|N_FLAG|X_FLAG);
  1051.     if((status=Poke(ea_address, result, size)) != EXECUTE_OK)
  1052.       return(status);
  1053.   }
  1054.  
  1055.   if(trace)
  1056.   {
  1057.     trace_record+="{Mnemonic {ADDQ";
  1058.     if (size==BYTE)
  1059.       trace_record+=".B ";
  1060.     else if (size==WORD)
  1061.       trace_record+=".W ";
  1062.     else if (size==LONG)
  1063.       trace_record+=".L ";
  1064.     trace_record+="#$";
  1065.     trace_record+=IntToString(immediate_data,1);
  1066.     trace_record+=",";
  1067.     trace_record+=ea_description;
  1068.     trace_record+="}} ";
  1069.   }
  1070.   return(EXECUTE_OK);
  1071. }
  1072.  
  1073. ///////////////////////////////////////////////////////////////////////////////
  1074. // Execute the 'ADDX' instruction 
  1075. ///////////////////////////////////////////////////////////////////////////////
  1076. int m68000::ExecuteADDX(int opcode, String& trace_record, int trace)
  1077. {
  1078.   int status, size, in_register_flag;
  1079.   unsigned long src_address, dest_address;
  1080.   unsigned int result, src, dest;
  1081.   String mnemonic;
  1082.  
  1083.   size = (opcode & 0x00c0) >> 6;
  1084.  
  1085.   if(trace)
  1086.   {
  1087.     mnemonic += "{Mnemonic {ADDX";
  1088.     if (size == BYTE)
  1089.       mnemonic += ".B ";
  1090.     else if (size == WORD)
  1091.       mnemonic += ".W ";
  1092.     else if (size == LONG)
  1093.       mnemonic += ".L ";
  1094.   }
  1095.  
  1096.   // Get the addresses
  1097.   if(opcode & 8)
  1098.   {
  1099.     if((status = ComputeEffectiveAddress(src_address, in_register_flag,
  1100.             mnemonic, 0x20 | (opcode & 7) , size, trace)) != EXECUTE_OK)
  1101.     { return(status); }
  1102.  
  1103.     if(trace)
  1104.       mnemonic += ",";
  1105.  
  1106.     if((status = ComputeEffectiveAddress(dest_address, in_register_flag,
  1107.             mnemonic, 0x20 | ((opcode & 0x0e00) >> 9), size, trace)) != EXECUTE_OK)
  1108.     { return(status); }
  1109.  
  1110.     if((status = Peek(src_address, src, size)) != EXECUTE_OK)
  1111.       return(status);
  1112.     if((status = Peek(dest_address, dest, size)) != EXECUTE_OK)
  1113.       return(status);
  1114.   }
  1115.   else
  1116.   {
  1117.     src_address = D0_INDEX + (opcode & 0x0007);
  1118.     src = register_value[src_address];
  1119.     dest_address = D0_INDEX + ((opcode & 0x0e00) >> 9);
  1120.     dest = register_value[dest_address];
  1121.     if(trace)
  1122.     {
  1123.       mnemonic += register_data[src_address].name;
  1124.       mnemonic += ",";
  1125.       mnemonic += register_data[dest_address].name;
  1126.     }
  1127.   }
  1128.  
  1129.   if(register_value[SR_INDEX] & X_FLAG)
  1130.     result = src + dest + 1;
  1131.   else
  1132.     result = src + dest;
  1133.  
  1134.   if(size == BYTE)
  1135.     result = result&0xff;
  1136.   else if (size == WORD)
  1137.     result = result & 0xffff;
  1138.   else if (size == LONG)
  1139.     result = result & 0xffffffff;
  1140.  
  1141.   SetConditionCodes(src, dest, result, size,
  1142.                     ADDITION, C_FLAG|V_FLAG|N_FLAG|X_FLAG);
  1143.   if(result)
  1144.     register_value[SR_INDEX] &= ~Z_FLAG;
  1145.  
  1146.   if(opcode & 8)
  1147.   {
  1148.     if((status = Poke(dest_address, result, size)) != EXECUTE_OK)
  1149.       return(status);
  1150.   }
  1151.   else
  1152.   {
  1153.     SetRegister(dest_address, result, size);
  1154.   }
  1155.  
  1156.   if(trace)
  1157.   {
  1158.     mnemonic+="}} ";
  1159.     trace_record += mnemonic;
  1160.   }
  1161.   return(EXECUTE_OK);
  1162. }
  1163.  
  1164. ///////////////////////////////////////////////////////////////////////////////
  1165. // Execute the 'AND' instruction 
  1166. ///////////////////////////////////////////////////////////////////////////////
  1167. int m68000::ExecuteAND(int opcode, String& trace_record, int trace)
  1168. {
  1169.   int status, size, in_register_flag;
  1170.   unsigned long ea_address, register_number;
  1171.   unsigned int result, ea_data;
  1172.   String mnemonic, ea_description;
  1173.  
  1174.   size=(opcode&0x00c0) >> 6;
  1175.  
  1176.   // Get the <ea> data address
  1177.   if((status=ComputeEffectiveAddress(ea_address, in_register_flag,
  1178.                   ea_description, opcode & 0x3f, size, trace)) != EXECUTE_OK)
  1179.   { return(status); }
  1180.  
  1181.   // Fetch the <ea> data 
  1182.   if(in_register_flag)
  1183.     ea_data=register_value[ea_address];
  1184.   else
  1185.     if((status=Peek(ea_address, ea_data, size)) != EXECUTE_OK)
  1186.       return(status);
  1187.  
  1188.   // Get the register number
  1189.   register_number=D0_INDEX+((opcode&0x0e00) >> 9);
  1190.  
  1191.   if(trace)
  1192.   {
  1193.     mnemonic+="{Mnemonic {AND";
  1194.     if (size==BYTE)
  1195.       mnemonic+=".B ";
  1196.     else if (size==WORD)
  1197.       mnemonic+=".W ";
  1198.     else if (size==LONG)
  1199.       mnemonic+=".L ";
  1200.   }
  1201.  
  1202.   if(opcode & 0x0100)    // <Dn> & <ea> -> <ea>
  1203.   {
  1204.     if(trace)
  1205.     {
  1206.       mnemonic+=register_data[register_number].name;
  1207.       mnemonic+=",";
  1208.       mnemonic+=ea_description;
  1209.     }
  1210.     result=register_value[register_number]&ea_data;
  1211.     SetConditionCodes(register_value[register_number], ea_data, result, size,
  1212.                       OTHER, V_FLAG|C_FLAG|Z_FLAG|N_FLAG);
  1213.     if((status=Poke(ea_address, result, size)) != EXECUTE_OK)
  1214.       return(status);
  1215.   }
  1216.   else                   // <ea> & <Dn> -> <Dn>
  1217.   {
  1218.     if(trace)
  1219.     {
  1220.       mnemonic+=ea_description;
  1221.       mnemonic+=",";
  1222.       mnemonic+=register_data[register_number].name;
  1223.     }
  1224.     result=ea_data®ister_value[register_number];
  1225.     SetConditionCodes(ea_data, register_value[register_number], result, size,
  1226.                       OTHER, V_FLAG|C_FLAG|Z_FLAG|N_FLAG);
  1227.     SetRegister(register_number, result, size);
  1228.   }
  1229.  
  1230.   if(trace)
  1231.   {
  1232.     mnemonic+="}} ";
  1233.     trace_record+=mnemonic;
  1234.   }
  1235.   return(EXECUTE_OK);
  1236. }
  1237.  
  1238. ///////////////////////////////////////////////////////////////////////////////
  1239. // Execute the 'ANDI' instruction 
  1240. ///////////////////////////////////////////////////////////////////////////////
  1241. int m68000::ExecuteANDI(int opcode, String& trace_record, int trace)
  1242. {
  1243.   int status, size, in_register;
  1244.   unsigned long dest_addr, src_addr;
  1245.   unsigned int result, src, dest;
  1246.   String mnemonic;
  1247.  
  1248.   size=(opcode&0x00c0) >> 6;
  1249.  
  1250.   if(trace)
  1251.   {
  1252.     mnemonic+="{Mnemonic {ANDI";
  1253.     if (size==BYTE)
  1254.       mnemonic+=".B ";
  1255.     else if (size==WORD)
  1256.       mnemonic+=".W ";
  1257.     else if (size==LONG)
  1258.       mnemonic+=".L ";
  1259.   }
  1260.  
  1261.   // Get the immediate data pointer
  1262.   if((status=ComputeEffectiveAddress(src_addr, in_register, mnemonic,
  1263.                     0x3c, size, trace)) != EXECUTE_OK)
  1264.   { return(status); }
  1265.  
  1266.   // Fetch the immediate data
  1267.   if((status=Peek(src_addr, src, size)) != EXECUTE_OK)
  1268.     return(status);
  1269.  
  1270.   if(trace)
  1271.     mnemonic+=",";
  1272.  
  1273.   // Get the destination data pointer
  1274.   if((status=ComputeEffectiveAddress(dest_addr, in_register, mnemonic,
  1275.                     opcode & 0x3f, size, trace)) != EXECUTE_OK)
  1276.   {
  1277.     return(status);
  1278.   }
  1279.  
  1280.   if(in_register)
  1281.   {
  1282.     dest=register_value[dest_addr];
  1283.     result=dest&src;
  1284.     SetConditionCodes(src,dest,result,size,
  1285.                       OTHER, C_FLAG|V_FLAG|Z_FLAG|N_FLAG);
  1286.     SetRegister(dest_addr,result,size);
  1287.   } 
  1288.   else
  1289.   {
  1290.     if((status=Peek(dest_addr, dest, size)) != EXECUTE_OK)
  1291.       return(status);
  1292.     result=dest&src;
  1293.     SetConditionCodes(src,dest,result,size,
  1294.                       OTHER, C_FLAG|V_FLAG|Z_FLAG|N_FLAG);
  1295.     if((status=Poke(dest_addr, result, size)) != EXECUTE_OK)
  1296.       return(status);
  1297.   }
  1298.  
  1299.   if (trace)
  1300.   {
  1301.     mnemonic+="}} ";
  1302.     trace_record+=mnemonic;
  1303.   }
  1304.   return(EXECUTE_OK);
  1305. }
  1306.  
  1307. ///////////////////////////////////////////////////////////////////////////////
  1308. // Execute the 'ANDItoCCR' instruction 
  1309. ///////////////////////////////////////////////////////////////////////////////
  1310. int m68000::ExecuteANDItoCCR(int opcode, String& trace_record, int trace)
  1311. {
  1312.   int status, size, in_register_flag;
  1313.   unsigned long src_addr;
  1314.   unsigned int src;
  1315.   String mnemonic;
  1316.  
  1317.   size=BYTE;
  1318.  
  1319.   if(trace)
  1320.     mnemonic+="{Mnemonic {ANDI.B ";
  1321.  
  1322.   // Get the immediate data pointer
  1323.   if((status=ComputeEffectiveAddress(src_addr, in_register_flag, mnemonic,
  1324.                     0x3c, size, trace)) != EXECUTE_OK)
  1325.   { return(status); }
  1326.  
  1327.   // Fetch the immediate data
  1328.   if((status=Peek(src_addr, src, size)) != EXECUTE_OK)
  1329.     return(status);
  1330.  
  1331.   SetRegister(SR_INDEX, (register_value[SR_INDEX]&src), BYTE);
  1332.   if (trace)
  1333.   {
  1334.     mnemonic+=",CCR}} ";
  1335.     trace_record+=mnemonic;
  1336.   }
  1337.   return(EXECUTE_OK);
  1338. }
  1339.  
  1340. ///////////////////////////////////////////////////////////////////////////////
  1341. // Execute the 'ANDItoSR' instruction 
  1342. ///////////////////////////////////////////////////////////////////////////////
  1343. int m68000::ExecuteANDItoSR(int opcode, String& trace_record, int trace)
  1344. {
  1345.   int status, size, in_register_flag;
  1346.   unsigned long src_addr;
  1347.   unsigned int src;
  1348.   String mnemonic;
  1349.  
  1350.   // Make sure we're in supervisor mode or trap
  1351.   if (!(register_value[SR_INDEX] & S_FLAG))
  1352.   {
  1353.     SetRegister(PC_INDEX, register_value[PC_INDEX]-2, LONG);
  1354.     if((status=ProcessException(8)) != EXECUTE_OK)
  1355.       return(status);
  1356.     if(trace);
  1357.       trace_record+="{Mnemonic {Privilege Violation Exception}} ";
  1358.     return(EXECUTE_PRIVILEGED_OK);
  1359.   }
  1360.  
  1361.   size=WORD;
  1362.  
  1363.   if(trace)
  1364.     mnemonic+="{Mnemonic {ANDI.W ";
  1365.  
  1366.   // Get the immediate data pointer
  1367.   if((status=ComputeEffectiveAddress(src_addr, in_register_flag, mnemonic,
  1368.                     0x3c, size, trace)) != EXECUTE_OK)
  1369.   { return(status); }
  1370.  
  1371.   // Fetch the immediate data
  1372.   if((status=Peek(src_addr, src, size)) != EXECUTE_OK)
  1373.     return(status);
  1374.  
  1375.   SetRegister(SR_INDEX, register_value[SR_INDEX]&src, WORD);
  1376.  
  1377.   if (trace)
  1378.   {
  1379.     mnemonic+=",SR}} ";
  1380.     trace_record+=mnemonic;
  1381.   }
  1382.   return(EXECUTE_PRIVILEGED_OK);
  1383. }
  1384.  
  1385. ///////////////////////////////////////////////////////////////////////////////
  1386. // Execute the 'ASL' instruction 
  1387. ///////////////////////////////////////////////////////////////////////////////
  1388. int m68000::ExecuteASL(int opcode, String& trace_record, int trace)
  1389. {
  1390.   int status, size, in_register_flag, shift_count;
  1391.   unsigned long address;
  1392.   unsigned int data;
  1393.   String ea_description;
  1394.  
  1395.   size=(opcode&0x00c0) >> 6;
  1396.  
  1397.   // Check to see if this is a memory or register shift 
  1398.   if(size == 3)
  1399.   {
  1400.     size=WORD;    // Memory always shifts a word
  1401.  
  1402.     // Get the address
  1403.     if((status=ComputeEffectiveAddress(address,in_register_flag,ea_description,
  1404.                  opcode & 0x3f, size, trace)) != EXECUTE_OK)
  1405.     { return(status); }
  1406.  
  1407.     // Fetch the data
  1408.     if((status=Peek(address, data, size)) != EXECUTE_OK)
  1409.       return(status);
  1410.  
  1411.     // Shift the data to the left by one bit.
  1412.     data=data << 1;
  1413.  
  1414.     // Store the shifted data
  1415.     if((status=Poke(address, data, size)) != EXECUTE_OK)
  1416.       return(status);
  1417.  
  1418.     SetConditionCodes(0, 0, data, size,
  1419.         OTHER, N_FLAG|Z_FLAG|X_FLAG|C_FLAG|V_FLAG); 
  1420.     if(data&0x00010000)
  1421.     {
  1422.       register_value[SR_INDEX] |= C_FLAG;
  1423.       register_value[SR_INDEX] |= X_FLAG;
  1424.     }
  1425.     if(!((data&0x000180000)==0x000180000) && !((data&0x000180000)==0x00000000))
  1426.       register_value[SR_INDEX] |= V_FLAG;
  1427.   }
  1428.   else
  1429.   {
  1430.     // Compute the shift count
  1431.     if(opcode&32)
  1432.     {
  1433.       shift_count=register_value[D0_INDEX+((opcode&0x0e00) >> 9)] & 0x3f;
  1434.       if(trace)
  1435.         ea_description=register_data[D0_INDEX+((opcode&0x0e00) >> 9)].name;
  1436.     }
  1437.     else
  1438.     {
  1439.       if((shift_count=(opcode&0x0e00) >> 9) == 0)
  1440.         shift_count=8;
  1441.  
  1442.       if(trace)
  1443.       {
  1444.         ea_description="#$";
  1445.         ea_description+=IntToString(shift_count,1);
  1446.       }
  1447.     }
  1448.  
  1449.     if(trace)
  1450.     {
  1451.       ea_description+=",";
  1452.       ea_description+=register_data[D0_INDEX+(opcode&7)].name;
  1453.     }
  1454.  
  1455.     unsigned int carry, overflow=0;
  1456.     unsigned int carry_mask, overflow_mask;
  1457.  
  1458.     // Setup masks
  1459.     if(size==BYTE)
  1460.     {
  1461.       carry_mask=0x80;
  1462.       overflow_mask=0xc0;
  1463.     }
  1464.     else if(size==WORD)
  1465.     {
  1466.       carry_mask=0x8000;
  1467.       overflow_mask=0xc000;
  1468.     }
  1469.     else
  1470.     {
  1471.       carry_mask=0x80000000;
  1472.       overflow_mask=0xc0000000;
  1473.     }
  1474.  
  1475.     // Perform the shift on the data
  1476.     data=register_value[D0_INDEX+(opcode&7)];
  1477.     for(int t=0;t<shift_count;++t)
  1478.     {
  1479.       carry=data & carry_mask;
  1480.       if(!((data&overflow_mask)==overflow_mask) && !((data&overflow_mask)==0))
  1481.         overflow |= 1;
  1482.  
  1483.       data=data << 1;
  1484.     }
  1485.  
  1486.     SetRegister(D0_INDEX+(opcode&7), data, size);
  1487.  
  1488.     SetConditionCodes(0, 0, data, size,
  1489.         OTHER, N_FLAG|Z_FLAG|X_FLAG|C_FLAG|V_FLAG); 
  1490.     if(overflow)
  1491.       register_value[SR_INDEX] |= V_FLAG;
  1492.     if(carry)
  1493.     {
  1494.       register_value[SR_INDEX] |= C_FLAG;
  1495.       register_value[SR_INDEX] |= X_FLAG;
  1496.     }
  1497.   }
  1498.  
  1499.   if (trace)
  1500.   {
  1501.     trace_record+="{Mnemonic {ASL";
  1502.     if(size==BYTE)
  1503.       trace_record+=".B ";
  1504.     else if(size==WORD)
  1505.       trace_record+=".W ";
  1506.     else if(size==LONG)
  1507.       trace_record+=".L ";
  1508.     trace_record+=ea_description;
  1509.     trace_record+="}} ";
  1510.   }
  1511.   return(EXECUTE_OK);
  1512. }
  1513.  
  1514. ///////////////////////////////////////////////////////////////////////////////
  1515. // Execute the 'ASR' instruction 
  1516. ///////////////////////////////////////////////////////////////////////////////
  1517. int m68000::ExecuteASR(int opcode, String& trace_record, int trace)
  1518. {
  1519.   int status, size, in_register_flag, shift_count;
  1520.   unsigned long address;
  1521.   unsigned int data;
  1522.   String ea_description;
  1523.  
  1524.   size=(opcode&0x00c0) >> 6;
  1525.  
  1526.   // Check to see if this is a memory or register shift 
  1527.   if(size == 3)
  1528.   {
  1529.     size=WORD;    // Memory always shifts a word
  1530.  
  1531.     // Get the address
  1532.     if((status=ComputeEffectiveAddress(address,in_register_flag,ea_description,
  1533.                  opcode & 0x3f, size, trace)) != EXECUTE_OK)
  1534.     { return(status); }
  1535.  
  1536.     // Fetch the data
  1537.     if((status=Peek(address, data, size)) != EXECUTE_OK)
  1538.       return(status);
  1539.  
  1540.     // Set the condition codes
  1541.     SetConditionCodes(0, 0, data >> 1, size,
  1542.         OTHER, N_FLAG|Z_FLAG|X_FLAG|C_FLAG|V_FLAG); 
  1543.     if(data&0x0001)
  1544.     {
  1545.       register_value[SR_INDEX] |= C_FLAG;
  1546.       register_value[SR_INDEX] |= X_FLAG;
  1547.     }
  1548.  
  1549.     // Shift the data to the right by one bit.
  1550.     data=data >> 1;
  1551.  
  1552.     // Replicate the old high order bit
  1553.     if(data & 0x4000)
  1554.       data |= 0x8000;
  1555.     else
  1556.       data &= ~0x8000;
  1557.  
  1558.     // Store the shifted data
  1559.     if((status=Poke(address, data, size)) != EXECUTE_OK)
  1560.       return(status);
  1561.   }
  1562.   else
  1563.   {
  1564.     // Compute the shift count
  1565.     if(opcode&32)
  1566.     {
  1567.       shift_count=register_value[D0_INDEX+((opcode&0x0e00) >> 9)] & 0x3f;
  1568.       if(trace)
  1569.         ea_description=register_data[D0_INDEX+((opcode&0x0e00) >> 9)].name;
  1570.     }
  1571.     else
  1572.     {
  1573.       if((shift_count=(opcode&0x0e00) >> 9) == 0)
  1574.         shift_count=8;
  1575.  
  1576.       if(trace)
  1577.       {
  1578.         ea_description="#$";
  1579.         ea_description+=IntToString(shift_count,1);
  1580.       }
  1581.     }
  1582.  
  1583.     if(trace)
  1584.     {
  1585.       ea_description+=",";
  1586.       ea_description+=register_data[D0_INDEX+(opcode&7)].name;
  1587.     }
  1588.  
  1589.     unsigned int carry, replicate_mask, msb;
  1590.  
  1591.     // Setup masks
  1592.     if(size==BYTE)
  1593.     {
  1594.       replicate_mask=0x40;
  1595.       msb=0x80;
  1596.     }
  1597.     else if(size==WORD)
  1598.     {
  1599.       replicate_mask=0x4000;
  1600.       msb=0x8000;
  1601.     }
  1602.     else
  1603.     {
  1604.       replicate_mask=0x40000000;
  1605.       msb=0x80000000;
  1606.     }
  1607.  
  1608.     // Perform the shift on the data
  1609.     data=register_value[D0_INDEX+(opcode&7)];
  1610.     for(int t=0;t<shift_count;++t)
  1611.     {
  1612.       carry=data & 0x00000001;
  1613.       data=data >> 1;
  1614.  
  1615.       // Replicate the old high order bit
  1616.       if(data & replicate_mask)
  1617.         data |= msb;
  1618.       else
  1619.         data &= ~msb;
  1620.     }
  1621.  
  1622.     SetRegister(D0_INDEX+(opcode&7), data, size);
  1623.  
  1624.     SetConditionCodes(0, 0, data, size,
  1625.         OTHER, N_FLAG|Z_FLAG|X_FLAG|C_FLAG|V_FLAG); 
  1626.     if(carry)
  1627.     {
  1628.       register_value[SR_INDEX] |= C_FLAG;
  1629.       register_value[SR_INDEX] |= X_FLAG;
  1630.     }
  1631.   }
  1632.  
  1633.   if (trace)
  1634.   {
  1635.     trace_record+="{Mnemonic {ASR";
  1636.     if(size==BYTE)
  1637.       trace_record+=".B ";
  1638.     else if(size==WORD)
  1639.       trace_record+=".W ";
  1640.     else if(size==LONG)
  1641.       trace_record+=".L ";
  1642.     trace_record+=ea_description;
  1643.     trace_record+="}} ";
  1644.   }
  1645.   return(EXECUTE_OK);
  1646. }
  1647.  
  1648. ///////////////////////////////////////////////////////////////////////////////
  1649. // Execute the 'Bit' instructions (BCHG, BCLR, BSET, & BTST)
  1650. ///////////////////////////////////////////////////////////////////////////////
  1651. int m68000::ExecuteBit(int opcode, String& trace_record, int trace)
  1652. {
  1653.   int status, size, in_register_flag;
  1654.   unsigned long ea_address, register_number;
  1655.   unsigned int ea_data, bit_number;
  1656.   String mnemonic, ea_description;
  1657.  
  1658.   // Get the bit number we're supposed to be checking
  1659.   if(opcode & 256)
  1660.   { 
  1661.     register_number=D0_INDEX+((opcode&0x0e00) >> 9);
  1662.     bit_number=register_value[register_number];
  1663.     if(trace)
  1664.       ea_description=register_data[register_number].name;
  1665.   }
  1666.   else
  1667.   {
  1668.     unsigned long address;
  1669.  
  1670.     // Get the immediate data pointer
  1671.     if((status=ComputeEffectiveAddress(address, in_register_flag,
  1672.                    ea_description, 0x3c, WORD, trace)) != EXECUTE_OK)
  1673.     { return(status); }
  1674.  
  1675.     // Fetch the immediate data
  1676.     if((status=Peek(address, bit_number, WORD)) != EXECUTE_OK)
  1677.       return(status);
  1678.   }
  1679.  
  1680.   if(trace) ea_description+=",";
  1681.  
  1682.   // Determine the size of the operation (BYTE or LONG)
  1683.   if((opcode & 0x38) == 0)
  1684.     size = LONG;
  1685.   else
  1686.     size = BYTE;
  1687.  
  1688.   // Get the <ea> data address
  1689.   if((status=ComputeEffectiveAddress(ea_address, in_register_flag,
  1690.                   ea_description, opcode & 0x3f, size, trace)) != EXECUTE_OK)
  1691.   { return(status); }
  1692.  
  1693.   // Fetch the <ea> data 
  1694.   if(in_register_flag)
  1695.   {
  1696.     ea_data=register_value[ea_address];
  1697.     bit_number = (1 << (bit_number & 0x1F));
  1698.   }
  1699.   else
  1700.   {
  1701.     if((status=Peek(ea_address, ea_data, BYTE)) != EXECUTE_OK)
  1702.       return(status);
  1703.     bit_number = (1 << (bit_number & 0x07));
  1704.   }
  1705.  
  1706.   // Set the Zero Flag
  1707.   if(ea_data & bit_number)
  1708.     register_value[SR_INDEX] &= ~Z_FLAG;
  1709.   else
  1710.     register_value[SR_INDEX] |= Z_FLAG;
  1711.  
  1712.   switch ((opcode & 0x00c0) >> 6)
  1713.   {
  1714.     case 0:    // BTST
  1715.       if(trace)
  1716.         mnemonic+="{Mnemonic {BTST";
  1717.       break;
  1718.  
  1719.     case 1:    // BCHG
  1720.       if(trace)
  1721.         mnemonic+="{Mnemonic {BCHG";
  1722.       if(ea_data & bit_number)
  1723.         ea_data &= ~bit_number;
  1724.       else
  1725.         ea_data |= bit_number;
  1726.       break;
  1727.  
  1728.     case 2:    // BCLR
  1729.       if(trace)
  1730.         mnemonic+="{Mnemonic {BCLR";
  1731.       ea_data &= ~bit_number;
  1732.       break;
  1733.  
  1734.     case 3:    // BSET
  1735.       if(trace)
  1736.         mnemonic+="{Mnemonic {BSET";
  1737.       ea_data |= bit_number;
  1738.       break;
  1739.   }
  1740.  
  1741.   // If it's not BTST then write the result back
  1742.   if(((opcode & 0x00c0) >> 6)!=0)
  1743.   {
  1744.     if(in_register_flag)
  1745.       SetRegister(ea_address, ea_data, LONG);
  1746.     else
  1747.       if((status=Poke(ea_address, ea_data, BYTE)) != EXECUTE_OK)
  1748.         return(status);
  1749.   }
  1750.  
  1751.   if(trace)
  1752.   {
  1753.     if(size==BYTE)
  1754.       mnemonic+=".B ";
  1755.     else
  1756.       mnemonic+=".L ";
  1757.     trace_record+=mnemonic;
  1758.     trace_record+=ea_description;
  1759.     trace_record+="}} ";
  1760.   }
  1761.   return(EXECUTE_OK);
  1762. }
  1763.  
  1764. ///////////////////////////////////////////////////////////////////////////////
  1765. // Execute the 'BRA' instruction 
  1766. ///////////////////////////////////////////////////////////////////////////////
  1767. int m68000::ExecuteBRA(int opcode, String& trace_record, int trace)
  1768. {
  1769.   unsigned int displacement, status;
  1770.   String mnemonic;
  1771.  
  1772.   if(trace) mnemonic="{Mnemonic {BRA";
  1773.  
  1774.   // Compute the displacement
  1775.   if((displacement=opcode&0xff)==0)
  1776.   {
  1777.     // Fetch the 16-bit displacement data
  1778.     status=Peek(register_value[PC_INDEX],displacement,WORD);
  1779.     if (status!=EXECUTE_OK)
  1780.       return(status);
  1781.  
  1782.     displacement=SignExtend(displacement,WORD);
  1783.     if (trace)
  1784.     {
  1785.       mnemonic+=".W $";
  1786.       mnemonic+=IntToString(displacement,4);
  1787.       mnemonic+="}} ";
  1788.       trace_record+=mnemonic;
  1789.     } 
  1790.   }
  1791.   else
  1792.   {
  1793.     displacement=SignExtend(displacement,BYTE);
  1794.     if (trace)
  1795.     {
  1796.       mnemonic+=".B $";
  1797.       mnemonic+=IntToString(displacement,2);
  1798.       mnemonic+="}} ";
  1799.       trace_record+=mnemonic;
  1800.     } 
  1801.   }
  1802.  
  1803.   SetRegister(PC_INDEX, register_value[PC_INDEX]+displacement, LONG);
  1804.   return(EXECUTE_OK);
  1805. }
  1806.  
  1807. ///////////////////////////////////////////////////////////////////////////////
  1808. // Execute the 'BSR' instruction 
  1809. ///////////////////////////////////////////////////////////////////////////////
  1810. int m68000::ExecuteBSR(int opcode, String& trace_record, int trace)
  1811. {
  1812.   unsigned int displacement, status;
  1813.   unsigned long addr;
  1814.   String mnemonic;
  1815.  
  1816.   if(trace) mnemonic="{Mnemonic {BSR";
  1817.  
  1818.   // Compute the displacement
  1819.   if((displacement=opcode&0xff)==0)
  1820.   {
  1821.     // Fetch the 16-bit displacement data
  1822.     status=Peek(register_value[PC_INDEX],displacement,WORD);
  1823.     if (status!=EXECUTE_OK)
  1824.       return(status);
  1825.  
  1826.     displacement=SignExtend(displacement,WORD);
  1827.     if(trace)
  1828.     {
  1829.       mnemonic+=".W $";
  1830.       mnemonic+=IntToString(displacement,4);
  1831.       mnemonic+="}} ";
  1832.     } 
  1833.   }
  1834.   else
  1835.   {
  1836.     displacement=SignExtend(displacement,BYTE);
  1837.     if(trace)
  1838.     {
  1839.       mnemonic+=".B $";
  1840.       mnemonic+=IntToString(displacement,2);
  1841.       mnemonic+="}}  ";
  1842.     } 
  1843.   }
  1844.  
  1845.   // Push the PC onto the stack
  1846.   if(register_value[SR_INDEX] & S_FLAG)
  1847.   {
  1848.     SetRegister(SSP_INDEX, register_value[SSP_INDEX]-4, LONG);
  1849.     addr=register_value[SSP_INDEX];
  1850.   }
  1851.   else
  1852.   {
  1853.     SetRegister(USP_INDEX, register_value[USP_INDEX]-4, LONG);
  1854.     addr=register_value[USP_INDEX];
  1855.   }
  1856.  
  1857.   if((opcode&0xff)==0)
  1858.   {
  1859.     if((status=Poke(addr, register_value[PC_INDEX]+2, LONG)) != EXECUTE_OK)
  1860.       return(status);
  1861.   }
  1862.   else
  1863.   {
  1864.     if((status=Poke(addr, register_value[PC_INDEX], LONG)) != EXECUTE_OK)
  1865.       return(status);
  1866.   }
  1867.  
  1868.   SetRegister(PC_INDEX, register_value[PC_INDEX]+displacement, LONG);
  1869.  
  1870.   if(trace)
  1871.     trace_record+=mnemonic;
  1872.  
  1873.   return(EXECUTE_OK);
  1874. }
  1875.  
  1876. ///////////////////////////////////////////////////////////////////////////////
  1877. // Execute the 'Bcc' instructions 
  1878. ///////////////////////////////////////////////////////////////////////////////
  1879. int m68000::ExecuteBcc(int opcode, String& trace_record, int trace)
  1880. {
  1881.   unsigned int displacement, branch, status;
  1882.   String mnemonic;
  1883.  
  1884.   // Compute the displacement
  1885.   if((displacement=opcode&0xff)==0)
  1886.   {
  1887.     // Fetch the 16-bit displacement data
  1888.     status=Peek(register_value[PC_INDEX],displacement,WORD);
  1889.     if (status!=EXECUTE_OK)
  1890.       return(status);
  1891.   }
  1892.  
  1893.   if(trace) mnemonic="{Mnemonic {B";
  1894.  
  1895.   // See if the branch should occur
  1896.   branch=CheckConditionCodes((opcode & 0x0f00) >> 8, mnemonic, trace);
  1897.  
  1898.   if((opcode&0xff)==0) 
  1899.   {
  1900.     if(trace)
  1901.     {
  1902.       mnemonic+=".W $";
  1903.       mnemonic+=IntToString(displacement,4);
  1904.     }
  1905.     displacement=SignExtend(displacement,WORD);
  1906.   }
  1907.   else
  1908.   {
  1909.     if(trace)
  1910.     {
  1911.       mnemonic+=".B $";
  1912.       mnemonic+=IntToString(displacement,2);
  1913.     }
  1914.     displacement=SignExtend(displacement,BYTE);
  1915.   }
  1916.  
  1917.   if(branch)
  1918.     SetRegister(PC_INDEX, register_value[PC_INDEX]+displacement, LONG);
  1919.   else if ((opcode&0xff)==0)
  1920.     SetRegister(PC_INDEX, register_value[PC_INDEX]+2, LONG);
  1921.  
  1922.   if(trace)
  1923.   {
  1924.     mnemonic+="}} ";
  1925.     trace_record+=mnemonic;
  1926.   }
  1927.   return(EXECUTE_OK);
  1928. }
  1929.  
  1930. ///////////////////////////////////////////////////////////////////////////////
  1931. // Execute the '' instruction 
  1932. ///////////////////////////////////////////////////////////////////////////////
  1933. int m68000::ExecuteCHK(int opcode, String& trace_record, int trace)
  1934. { 
  1935.   return(ExecuteInvalid(opcode, trace_record, trace));
  1936. }
  1937.  
  1938. ///////////////////////////////////////////////////////////////////////////////
  1939. // Execute the 'CLR' instruction
  1940. ///////////////////////////////////////////////////////////////////////////////
  1941. int m68000::ExecuteCLR(int opcode, String& trace_record, int trace)
  1942. {
  1943.   int status, size, in_register;
  1944.   unsigned long address;
  1945.   String mnemonic;
  1946.  
  1947.   size=(opcode&0x00c0) >> 6;
  1948.  
  1949.   if(trace)
  1950.   {
  1951.     mnemonic+="{Mnemonic {CLR";
  1952.     if (size==BYTE)
  1953.       mnemonic+=".B ";
  1954.     else if (size==WORD)
  1955.       mnemonic+=".W ";
  1956.     else if (size==LONG)
  1957.       mnemonic+=".L ";
  1958.   }
  1959.  
  1960.   // Get the destination data pointer
  1961.   if((status=ComputeEffectiveAddress(address, in_register, mnemonic,
  1962.                     opcode & 0x3f, size, trace)) != EXECUTE_OK)
  1963.   { return(status); }
  1964.  
  1965.   if(in_register)
  1966.   {
  1967.     SetConditionCodes(0, 0, 0, size, OTHER, C_FLAG|V_FLAG|Z_FLAG|N_FLAG);
  1968.     SetRegister(address, 0, size);
  1969.   }
  1970.   else
  1971.   {
  1972.     SetConditionCodes(0, 0, 0, size, OTHER, C_FLAG|V_FLAG|Z_FLAG|N_FLAG);
  1973.     if((status=Poke(address, 0, size)) != EXECUTE_OK)
  1974.       return(status);
  1975.   }
  1976.  
  1977.   if (trace)
  1978.   {
  1979.     mnemonic+="}} ";
  1980.     trace_record+=mnemonic;
  1981.   }
  1982.   return(EXECUTE_OK);
  1983. }
  1984.  
  1985. ///////////////////////////////////////////////////////////////////////////////
  1986. // Execute the 'CMP' instruction
  1987. ///////////////////////////////////////////////////////////////////////////////
  1988. int m68000::ExecuteCMP(int opcode, String& trace_record, int trace)
  1989. {
  1990.   int status, size, in_register_flag;
  1991.   unsigned long ea_address, register_number;
  1992.   unsigned int result, ea_data;
  1993.   String mnemonic, ea_description;
  1994.  
  1995.   size=(opcode&0x00c0) >> 6;
  1996.  
  1997.   // Get the <ea> data address
  1998.   if((status=ComputeEffectiveAddress(ea_address, in_register_flag,
  1999.                   ea_description, opcode & 0x3f, size, trace)) != EXECUTE_OK)
  2000.   { return(status); }
  2001.  
  2002.   // Fetch the <ea> data
  2003.   if(in_register_flag)
  2004.     ea_data=register_value[ea_address];
  2005.   else
  2006.     if((status=Peek(ea_address, ea_data, size)) != EXECUTE_OK)
  2007.       return(status);
  2008.  
  2009.   // Get the register number
  2010.   register_number=D0_INDEX+((opcode&0x0e00) >> 9);
  2011.  
  2012.   result=register_value[register_number]-ea_data;
  2013.   SetConditionCodes(ea_data, register_value[register_number], result, size,
  2014.                     SUBTRACTION, C_FLAG|V_FLAG|Z_FLAG|N_FLAG);
  2015.  
  2016.   if(trace)
  2017.   {
  2018.     mnemonic+="{Mnemonic {CMP";
  2019.     if (size==BYTE)
  2020.       mnemonic+=".B ";
  2021.     else if (size==WORD)
  2022.       mnemonic+=".W ";
  2023.     else if (size==LONG)
  2024.       mnemonic+=".L ";
  2025.     mnemonic+=ea_description;
  2026.     mnemonic+=",";
  2027.     mnemonic+=register_data[register_number].name;
  2028.     mnemonic+="}} ";
  2029.     trace_record+=mnemonic;
  2030.   }
  2031.   return(EXECUTE_OK);
  2032. }
  2033.  
  2034. ///////////////////////////////////////////////////////////////////////////////
  2035. // Execute the 'CMPA' instruction
  2036. ///////////////////////////////////////////////////////////////////////////////
  2037. int m68000::ExecuteCMPA(int opcode, String& trace_record, int trace)
  2038. {
  2039.   int status, size, in_register_flag;
  2040.   unsigned long ea_address, register_number;
  2041.   unsigned int result, ea_data;
  2042.   String mnemonic, ea_description;
  2043.  
  2044.   if(opcode&0x0100)
  2045.     size=LONG;
  2046.   else
  2047.     size=WORD;
  2048.  
  2049.   // Get the <ea> data address
  2050.   if((status=ComputeEffectiveAddress(ea_address, in_register_flag,
  2051.                   ea_description, opcode & 0x3f, size, trace)) != EXECUTE_OK)
  2052.   { return(status); }
  2053.  
  2054.   // Fetch the <ea> data
  2055.   if(in_register_flag)
  2056.     ea_data=register_value[ea_address];
  2057.   else
  2058.     if((status=Peek(ea_address, ea_data, size)) != EXECUTE_OK)
  2059.       return(status);
  2060.  
  2061.   ea_data=SignExtend(ea_data,size);
  2062.    
  2063.   // Get the register number
  2064.   register_number=A0_INDEX+((opcode&0x0e00) >> 9);
  2065.  
  2066.   // Adjust register_number if it's A7 and we're in supervisor mode
  2067.   if((register_number == USP_INDEX) && (register_value[SR_INDEX] & S_FLAG))
  2068.     register_number = SSP_INDEX;
  2069.  
  2070.   result=register_value[register_number]-ea_data;
  2071.   SetConditionCodes(ea_data, register_value[register_number], result, size,
  2072.                     SUBTRACTION, C_FLAG|V_FLAG|Z_FLAG|N_FLAG);
  2073.   if(trace)
  2074.   {
  2075.     mnemonic+="{Mnemonic {CMPA";
  2076.     if (size==WORD)
  2077.       mnemonic+=".W ";
  2078.     else if (size==LONG)
  2079.       mnemonic+=".L ";
  2080.     mnemonic+=ea_description;
  2081.     mnemonic+=",";
  2082.     mnemonic+=register_data[register_number].name;
  2083.     mnemonic+="}} ";
  2084.     trace_record+=mnemonic;
  2085.   }
  2086.   return(EXECUTE_OK);
  2087. }
  2088.  
  2089. ///////////////////////////////////////////////////////////////////////////////
  2090. // Execute the 'CMPI' instruction 
  2091. ///////////////////////////////////////////////////////////////////////////////
  2092. int m68000::ExecuteCMPI(int opcode, String& trace_record, int trace)
  2093. {
  2094.   int status, size, in_register;
  2095.   unsigned long dest_addr, src_addr;
  2096.   unsigned int result, src, dest;
  2097.   String mnemonic;
  2098.  
  2099.   size=(opcode&0x00c0) >> 6;
  2100.  
  2101.   if(trace)
  2102.   {
  2103.     mnemonic+="{Mnemonic {CMPI";
  2104.     if (size==BYTE)
  2105.       mnemonic+=".B ";
  2106.     else if (size==WORD)
  2107.       mnemonic+=".W ";
  2108.     else if (size==LONG)
  2109.       mnemonic+=".L ";
  2110.   }
  2111.  
  2112.   // Get the immediate data pointer
  2113.   if((status=ComputeEffectiveAddress(src_addr, in_register, mnemonic,
  2114.                     0x3c, size, trace)) != EXECUTE_OK)
  2115.   { return(status); }
  2116.  
  2117.   // Fetch the immediate data
  2118.   if((status=Peek(src_addr, src, size)) != EXECUTE_OK)
  2119.     return(status);
  2120.  
  2121.   if(trace)
  2122.     mnemonic+=",";
  2123.  
  2124.   // Get the destination data pointer
  2125.   if((status=ComputeEffectiveAddress(dest_addr, in_register, mnemonic,
  2126.                     opcode & 0x3f, size, trace)) != EXECUTE_OK)
  2127.   {
  2128.     return(status);
  2129.   }
  2130.  
  2131.   if(in_register)
  2132.   {
  2133.     dest=register_value[dest_addr];
  2134.     result=dest-src;
  2135.     SetConditionCodes(src, dest, result, size,
  2136.                       SUBTRACTION, C_FLAG|V_FLAG|Z_FLAG|N_FLAG);
  2137.   } 
  2138.   else
  2139.   {
  2140.     if((status=Peek(dest_addr, dest, size)) != EXECUTE_OK)
  2141.       return(status);
  2142.     result=dest-src;
  2143.     SetConditionCodes(src, dest, result, size,
  2144.                       SUBTRACTION, C_FLAG|V_FLAG|Z_FLAG|N_FLAG);
  2145.   }
  2146.  
  2147.   if (trace)
  2148.   {
  2149.     mnemonic+="}} ";
  2150.     trace_record+=mnemonic;
  2151.   }
  2152.   return(EXECUTE_OK);
  2153. }
  2154.  
  2155. ///////////////////////////////////////////////////////////////////////////////
  2156. // Execute the 'CMPM' instruction
  2157. ///////////////////////////////////////////////////////////////////////////////
  2158. int m68000::ExecuteCMPM(int opcode, String& trace_record, int trace)
  2159. {
  2160.   int status, size, in_register_flag;
  2161.   unsigned long src_address, dest_address;
  2162.   unsigned int result, src, dest;
  2163.   String mnemonic;
  2164.  
  2165.   size = (opcode & 0x00c0) >> 6;
  2166.  
  2167.   if(trace)
  2168.   {
  2169.     mnemonic += "{Mnemonic {CMPM";
  2170.     if(size == BYTE)
  2171.       mnemonic += ".B ";
  2172.     else if(size == WORD)
  2173.       mnemonic += ".W ";
  2174.     else if(size == LONG)
  2175.       mnemonic += ".L ";
  2176.   }
  2177.  
  2178.   // Get the addresses
  2179.   if((status = ComputeEffectiveAddress(src_address, in_register_flag,
  2180.           mnemonic, 0x18 | (opcode&7) , size, trace)) != EXECUTE_OK)
  2181.   { return(status); }
  2182.  
  2183.   if (trace) mnemonic += ",";
  2184.  
  2185.   if((status = ComputeEffectiveAddress(dest_address, in_register_flag,
  2186.           mnemonic, 0x18 | ((opcode&0x0e00)>>9), size, trace)) != EXECUTE_OK)
  2187.   { return(status); }
  2188.  
  2189.   if((status = Peek(src_address, src, size)) != EXECUTE_OK)
  2190.     return(status);
  2191.   if((status = Peek(dest_address, dest, size)) != EXECUTE_OK)
  2192.     return(status);
  2193.  
  2194.   result = dest - src;
  2195.   SetConditionCodes(src, dest, result, size,
  2196.                     SUBTRACTION, C_FLAG|V_FLAG|N_FLAG|Z_FLAG);
  2197.  
  2198.   if(trace)
  2199.   {
  2200.     mnemonic += "}} ";
  2201.     trace_record += mnemonic;
  2202.   }
  2203.   return(EXECUTE_OK);
  2204. }
  2205.  
  2206. ///////////////////////////////////////////////////////////////////////////////
  2207. // Execute the 'DBcc' instruction 
  2208. ///////////////////////////////////////////////////////////////////////////////
  2209. int m68000::ExecuteDBcc(int opcode, String& trace_record, int trace)
  2210. {
  2211.   unsigned int displacement, status, register_number, condition_code;
  2212.   String mnemonic;
  2213.  
  2214.   if(trace) mnemonic="{Mnemonic {DB";
  2215.  
  2216.   // Fetch the 16-bit displacement data
  2217.   if((status=Peek(register_value[PC_INDEX],displacement,WORD)) != EXECUTE_OK)
  2218.     return(status);
  2219.  
  2220.   displacement=SignExtend(displacement,WORD);
  2221.  
  2222.   // Check the condition code
  2223.   condition_code=CheckConditionCodes((opcode & 0x0f00) >> 8, mnemonic, trace);
  2224.  
  2225.   // Get the register number that we are counting with 
  2226.   register_number = D0_INDEX+(opcode&7);
  2227.  
  2228.   if(trace)
  2229.   {
  2230.     mnemonic+=".W ";
  2231.     mnemonic+=register_data[register_number].name;
  2232.     mnemonic+=",$";
  2233.     mnemonic+=IntToString(displacement,4);
  2234.   }
  2235.  
  2236.   // If condition code is not true then preform Decrement and Branch
  2237.   if(!condition_code)
  2238.   {
  2239.     SetRegister(register_number, register_value[register_number]-1, WORD);
  2240.     if((register_value[register_number]&0xffff) == 0xffff)
  2241.       SetRegister(PC_INDEX, register_value[PC_INDEX]+2, LONG);
  2242.     else
  2243.       SetRegister(PC_INDEX, register_value[PC_INDEX]+displacement, LONG);
  2244.   }
  2245.   else
  2246.   {
  2247.     SetRegister(PC_INDEX, register_value[PC_INDEX]+2, LONG);
  2248.   }
  2249.  
  2250.   if(trace)
  2251.   {
  2252.     mnemonic+="}} ";
  2253.     trace_record+=mnemonic;
  2254.   }
  2255.   return(EXECUTE_OK);
  2256. }
  2257.  
  2258. ///////////////////////////////////////////////////////////////////////////////
  2259. // Execute the 'DIVS' instruction 
  2260. ///////////////////////////////////////////////////////////////////////////////
  2261. int m68000::ExecuteDIVS(int opcode, String& trace_record, int trace)
  2262. {
  2263.   int status, in_register_flag, positive_result;
  2264.   unsigned long ea_address, register_number;
  2265.   int ea_data, high_result, low_result, data;
  2266.   String ea_description;
  2267.  
  2268.   // Get the <ea> data address
  2269.   if((status=ComputeEffectiveAddress(ea_address, in_register_flag,
  2270.                   ea_description, opcode & 0x3f, WORD, trace)) != EXECUTE_OK)
  2271.   { return(status); }
  2272.  
  2273.   // Fetch the <ea> data
  2274.   if(in_register_flag)
  2275.     ea_data=register_value[ea_address] & 0xffff;
  2276.   else
  2277.   {
  2278.     unsigned int tmp;
  2279.  
  2280.     if((status=Peek(ea_address, tmp, WORD)) != EXECUTE_OK)
  2281.       return(status);
  2282.  
  2283.     ea_data = (int)tmp;
  2284.   } 
  2285.  
  2286.   // Are they trying to divide by zero?
  2287.   if(ea_data==0)
  2288.   {
  2289.     if((status=ProcessException(5)) != EXECUTE_OK)
  2290.       return(status);
  2291.     if(trace);
  2292.       trace_record+="{Mnemonic {Divide by Zero Exception}} ";
  2293.     return(EXECUTE_OK);
  2294.   }
  2295.  
  2296.   // Get the register number
  2297.   register_number=D0_INDEX+((opcode&0x0e00) >> 9);
  2298.   data=register_value[register_number];
  2299.  
  2300.   // Determine the sign of the result
  2301.   if((!(ea_data&0x8000) && !(data&0x8000000)) ||
  2302.       ((ea_data&0x8000) && (data&0x80000000)))
  2303.     positive_result=1;
  2304.   else
  2305.     positive_result=0;
  2306.  
  2307.   // Sign extend the ea_data and the register data
  2308.   ea_data=SignExtend(ea_data,WORD);
  2309.   data=SignExtend(data,LONG);
  2310.  
  2311.   high_result=data % ea_data;
  2312.   high_result=high_result << 16;
  2313.   low_result=data / ea_data;
  2314.  
  2315.   SetRegister(register_number, high_result|(low_result&0xffff), LONG);
  2316.   SetConditionCodes(0, 0, low_result, WORD, OTHER, C_FLAG|Z_FLAG|N_FLAG);
  2317.  
  2318.   // Set the overflow flag
  2319.   if((positive_result && (low_result & 0xffff8000)) ||
  2320.      (!positive_result && (~low_result & 0xffff8000)))
  2321.     register_value[SR_INDEX] |= V_FLAG;
  2322.   else
  2323.     register_value[SR_INDEX] &= ~V_FLAG;
  2324.  
  2325.   if(trace)
  2326.   {
  2327.     trace_record+="{Mnemonic {DIVS.W ";
  2328.     trace_record+=ea_description;
  2329.     trace_record+=",";
  2330.     trace_record+=register_data[register_number].name;
  2331.     trace_record+="}} ";
  2332.   }
  2333.   return(EXECUTE_OK);
  2334. }
  2335.  
  2336. ///////////////////////////////////////////////////////////////////////////////
  2337. // Execute the 'DIVU' instruction 
  2338. ///////////////////////////////////////////////////////////////////////////////
  2339. int m68000::ExecuteDIVU(int opcode, String& trace_record, int trace)
  2340. {
  2341.   int status, in_register_flag;
  2342.   unsigned long ea_address, register_number;
  2343.   unsigned int high_result, low_result, ea_data;
  2344.   String ea_description;
  2345.  
  2346.   // Get the <ea> data address
  2347.   if((status=ComputeEffectiveAddress(ea_address, in_register_flag,
  2348.                   ea_description, opcode & 0x3f, WORD, trace)) != EXECUTE_OK)
  2349.   { return(status); }
  2350.  
  2351.   // Fetch the <ea> data
  2352.   if(in_register_flag)
  2353.     ea_data=register_value[ea_address] & 0xffff;
  2354.   else
  2355.     if((status=Peek(ea_address, ea_data, WORD)) != EXECUTE_OK)
  2356.       return(status);
  2357.  
  2358.   // Are they trying to divide by zero?
  2359.   if(ea_data==0)
  2360.   {
  2361.     if((status=ProcessException(5)) != EXECUTE_OK)
  2362.       return(status);
  2363.     if(trace);
  2364.       trace_record+="{Mnemonic {Divide by Zero Exception}} ";
  2365.     return(EXECUTE_OK);
  2366.   }
  2367.  
  2368.   // Get the register number
  2369.   register_number=D0_INDEX+((opcode&0x0e00) >> 9);
  2370.  
  2371.   high_result=register_value[register_number] % ea_data;
  2372.   high_result=high_result << 16;
  2373.   low_result=register_value[register_number] / ea_data;
  2374.  
  2375.   SetRegister(register_number, high_result|(low_result&0xffff), LONG);
  2376.   SetConditionCodes(0, 0, low_result, WORD, OTHER, C_FLAG|Z_FLAG|N_FLAG);
  2377.  
  2378.   // Set the overflow flag
  2379.   if(low_result & 0xffff0000)
  2380.     register_value[SR_INDEX] |= V_FLAG;
  2381.   else
  2382.     register_value[SR_INDEX] &= ~V_FLAG;
  2383.  
  2384.   if(trace)
  2385.   {
  2386.     trace_record+="{Mnemonic {DIVU.W ";
  2387.     trace_record+=ea_description;
  2388.     trace_record+=",";
  2389.     trace_record+=register_data[register_number].name;
  2390.     trace_record+="}} ";
  2391.   }
  2392.   return(EXECUTE_OK);
  2393. }
  2394.  
  2395. ///////////////////////////////////////////////////////////////////////////////
  2396. // Execute the 'EOR' instruction
  2397. ///////////////////////////////////////////////////////////////////////////////
  2398. int m68000::ExecuteEOR(int opcode, String& trace_record, int trace)
  2399. {
  2400.   int status, size, in_register_flag;
  2401.   unsigned long ea_address, register_number;
  2402.   unsigned int result, ea_data;
  2403.   String mnemonic, ea_description;
  2404.  
  2405.   size=(opcode&0x00c0) >> 6;
  2406.  
  2407.   // Get the <ea> data address
  2408.   if((status=ComputeEffectiveAddress(ea_address, in_register_flag,
  2409.                   ea_description, opcode & 0x3f, size, trace)) != EXECUTE_OK)
  2410.   { return(status); }
  2411.  
  2412.   // Fetch the <ea> data
  2413.   if(in_register_flag)
  2414.     ea_data=register_value[ea_address];
  2415.   else
  2416.     if((status=Peek(ea_address, ea_data, size)) != EXECUTE_OK)
  2417.       return(status);
  2418.  
  2419.   // Get the register number
  2420.   register_number=D0_INDEX+((opcode&0x0e00) >> 9);
  2421.  
  2422.   result=register_value[register_number]^ea_data;
  2423.   SetConditionCodes(register_value[register_number], ea_data, result, size,
  2424.                     OTHER, V_FLAG|C_FLAG|Z_FLAG|N_FLAG);
  2425.   if(in_register_flag)
  2426.     SetRegister(ea_address, result, size);
  2427.   else
  2428.     if((status=Poke(ea_address, result, size)) != EXECUTE_OK)
  2429.       return(status);
  2430.  
  2431.   if(trace)
  2432.   {
  2433.     mnemonic+="{Mnemonic {EOR";
  2434.     if (size==BYTE)
  2435.       mnemonic+=".B ";
  2436.     else if (size==WORD)
  2437.       mnemonic+=".W ";
  2438.     else if (size==LONG)
  2439.       mnemonic+=".L ";
  2440.     mnemonic+=register_data[register_number].name;
  2441.     mnemonic+=",";
  2442.     mnemonic+=ea_description;
  2443.     mnemonic+="}} ";
  2444.     trace_record+=mnemonic;
  2445.   }
  2446.   return(EXECUTE_OK);
  2447. }
  2448.  
  2449. ///////////////////////////////////////////////////////////////////////////////
  2450. // Execute the 'EORI' instruction 
  2451. ///////////////////////////////////////////////////////////////////////////////
  2452. int m68000::ExecuteEORI(int opcode, String& trace_record, int trace)
  2453. {
  2454.   int status, size, in_register;
  2455.   unsigned long dest_addr, src_addr;
  2456.   unsigned int result, src, dest;
  2457.   String mnemonic;
  2458.  
  2459.   size=(opcode&0x00c0) >> 6;
  2460.  
  2461.   if(trace)
  2462.   {
  2463.     mnemonic+="{Mnemonic {EORI";
  2464.     if (size==BYTE)
  2465.       mnemonic+=".B ";
  2466.     else if (size==WORD)
  2467.       mnemonic+=".W ";
  2468.     else if (size==LONG)
  2469.       mnemonic+=".L ";
  2470.   }
  2471.  
  2472.   // Get the immediate data pointer
  2473.   if((status=ComputeEffectiveAddress(src_addr, in_register, mnemonic,
  2474.                     0x3c, size, trace)) != EXECUTE_OK)
  2475.   { return(status); }
  2476.  
  2477.   // Fetch the immediate data
  2478.   if((status=Peek(src_addr, src, size)) != EXECUTE_OK)
  2479.     return(status);
  2480.  
  2481.   if(trace)
  2482.     mnemonic+=",";
  2483.  
  2484.   // Get the destination data pointer
  2485.   if((status=ComputeEffectiveAddress(dest_addr, in_register, mnemonic,
  2486.                     opcode & 0x3f, size, trace)) != EXECUTE_OK)
  2487.   { return(status); }
  2488.  
  2489.   if(in_register)
  2490.   {
  2491.     dest=register_value[dest_addr];
  2492.     result=dest^src;
  2493.     SetConditionCodes(src,dest,result,size,
  2494.                       OTHER, C_FLAG|V_FLAG|Z_FLAG|N_FLAG);
  2495.     SetRegister(dest_addr,result,size);
  2496.   } 
  2497.   else
  2498.   {
  2499.     if((status=Peek(dest_addr, dest, size)) != EXECUTE_OK)
  2500.       return(status);
  2501.     result=dest^src;
  2502.     SetConditionCodes(src,dest,result,size,
  2503.                       OTHER, C_FLAG|V_FLAG|Z_FLAG|N_FLAG);
  2504.     if((status=Poke(dest_addr, result, size)) != EXECUTE_OK)
  2505.       return(status);
  2506.   }
  2507.  
  2508.   if (trace)
  2509.   {
  2510.     mnemonic+="}} ";
  2511.     trace_record+=mnemonic;
  2512.   }
  2513.   return(EXECUTE_OK);
  2514. }
  2515.  
  2516. ///////////////////////////////////////////////////////////////////////////////
  2517. // Execute the 'EORItoCCR' instruction 
  2518. ///////////////////////////////////////////////////////////////////////////////
  2519. int m68000::ExecuteEORItoCCR(int opcode, String& trace_record, int trace)
  2520. {
  2521.   int status, in_register_flag;
  2522.   unsigned long src_addr;
  2523.   unsigned int src;
  2524.   String ea_description;
  2525.  
  2526.   // Get the immediate data pointer
  2527.   if((status=ComputeEffectiveAddress(src_addr, in_register_flag, ea_description,
  2528.                 0x3c, BYTE, trace)) != EXECUTE_OK)
  2529.   { return(status); }
  2530.  
  2531.   // Fetch the immediate data
  2532.   if((status=Peek(src_addr, src, BYTE)) != EXECUTE_OK)
  2533.     return(status);
  2534.  
  2535.   SetRegister(SR_INDEX, register_value[SR_INDEX]^src, BYTE);
  2536.   if (trace)
  2537.   {
  2538.     trace_record+="{Mnemonic {EORI.B ";
  2539.     trace_record+=ea_description;
  2540.     trace_record+=",CCR}} ";
  2541.   }
  2542.   return(EXECUTE_OK);
  2543. }
  2544.  
  2545. ///////////////////////////////////////////////////////////////////////////////
  2546. // Execute the 'EORItoSR' instruction 
  2547. ///////////////////////////////////////////////////////////////////////////////
  2548. int m68000::ExecuteEORItoSR(int opcode, String& trace_record, int trace)
  2549. {
  2550.   int status, in_register_flag;
  2551.   unsigned long src_addr;
  2552.   unsigned int src;
  2553.   String ea_description;
  2554.  
  2555.   // Make sure we're in supervisor mode or trap
  2556.   if (!(register_value[SR_INDEX] & S_FLAG))
  2557.   {
  2558.     SetRegister(PC_INDEX, register_value[PC_INDEX]-2, LONG);
  2559.     if((status=ProcessException(8)) != EXECUTE_OK)
  2560.       return(status);
  2561.     if(trace);
  2562.       trace_record+="{Mnemonic {Privilege Violation Exception}} ";
  2563.     return(EXECUTE_PRIVILEGED_OK);
  2564.   }
  2565.  
  2566.   // Get the immediate data pointer
  2567.   if((status=ComputeEffectiveAddress(src_addr, in_register_flag, ea_description,
  2568.                     0x3c, WORD, trace)) != EXECUTE_OK)
  2569.   { return(status); }
  2570.  
  2571.   // Fetch the immediate data
  2572.   if((status=Peek(src_addr, src, WORD)) != EXECUTE_OK)
  2573.     return(status);
  2574.  
  2575.   SetRegister(SR_INDEX, register_value[SR_INDEX]^src , WORD);
  2576.  
  2577.   if (trace)
  2578.   {
  2579.     trace_record+="{Mnemonic {EORI.W ";
  2580.     trace_record+=ea_description;
  2581.     trace_record+=",SR}} ";
  2582.   }
  2583.   return(EXECUTE_PRIVILEGED_OK);
  2584. }
  2585.  
  2586. ///////////////////////////////////////////////////////////////////////////////
  2587. // Execute the 'EXG' instruction 
  2588. ///////////////////////////////////////////////////////////////////////////////
  2589. int m68000::ExecuteEXG(int opcode, String& trace_record, int trace)
  2590. {
  2591.   unsigned long tmp;
  2592.   unsigned int src_register,dest_register;
  2593.  
  2594.   // Get the src and dest registers numbers
  2595.   switch ((opcode&0x00f8) >> 3)
  2596.   {
  2597.     case 8:    // Data Registers
  2598.       src_register=D0_INDEX+((opcode&0x0e00) >> 9);
  2599.       dest_register=D0_INDEX+(opcode&0x0007);
  2600.       break;
  2601.     case 9:    // Address Registers
  2602.       src_register=A0_INDEX+((opcode&0x0e00) >> 9);
  2603.       dest_register=A0_INDEX+(opcode&0x0007);
  2604.       if(register_value[SR_INDEX]&S_FLAG)
  2605.       {
  2606.         if(src_register==USP_INDEX)
  2607.           src_register=SSP_INDEX;
  2608.         if(dest_register==USP_INDEX)
  2609.           dest_register=SSP_INDEX;
  2610.       }
  2611.       break;
  2612.     case 17:    // Data register and Address register
  2613.       src_register=D0_INDEX+((opcode&0x0e00) >> 9);
  2614.       dest_register=A0_INDEX+(opcode&0x0007);
  2615.       if(register_value[SR_INDEX]&S_FLAG)
  2616.       {
  2617.         if(dest_register==USP_INDEX)
  2618.           dest_register=SSP_INDEX;
  2619.       }
  2620.       break;
  2621.   }
  2622.  
  2623.   // Exchange the src and dest registers
  2624.   tmp=register_value[src_register];
  2625.   SetRegister(src_register, register_value[dest_register], LONG);
  2626.   SetRegister(dest_register, tmp, LONG);
  2627.     
  2628.   if (trace)
  2629.   {
  2630.     trace_record+="{Mnemonic {EXG.L ";
  2631.     trace_record+=register_data[src_register].name;
  2632.     trace_record+=",";
  2633.     trace_record+=register_data[dest_register].name;
  2634.     trace_record+="}} ";
  2635.   }
  2636.   return(EXECUTE_OK);
  2637. }
  2638.  
  2639. ///////////////////////////////////////////////////////////////////////////////
  2640. // Execute the 'EXT' instruction 
  2641. ///////////////////////////////////////////////////////////////////////////////
  2642. int m68000::ExecuteEXT(int opcode, String& trace_record, int trace)
  2643. {
  2644.   unsigned int register_number;
  2645.   unsigned long data;
  2646.  
  2647.   if(trace) trace_record+="{Mnemonic {EXT";
  2648.  
  2649.   // Get the data register number
  2650.   register_number=D0_INDEX+(opcode&0x0007);
  2651.   data=register_value[register_number];
  2652.  
  2653.   // Extend the data
  2654.   if(((opcode&0x01c0) >> 6) == 2)
  2655.   {
  2656.     data=SignExtend(data,BYTE);
  2657.     SetRegister(register_number, data, WORD);
  2658.     SetConditionCodes(0, 0, data, WORD, OTHER, V_FLAG|C_FLAG|Z_FLAG|N_FLAG);
  2659.     if(trace) trace_record+=".W ";
  2660.   }
  2661.   else
  2662.   {
  2663.     data=SignExtend(data,WORD);
  2664.     SetRegister(register_number, data, LONG); 
  2665.     SetConditionCodes(0, 0, data, LONG, OTHER, V_FLAG|C_FLAG|Z_FLAG|N_FLAG);
  2666.     if(trace) trace_record+=".L ";
  2667.   }
  2668.  
  2669.   if (trace)
  2670.   {
  2671.     trace_record+=register_data[register_number].name;
  2672.     trace_record+="}} ";
  2673.   }
  2674.   return(EXECUTE_OK);
  2675. }
  2676.  
  2677. ///////////////////////////////////////////////////////////////////////////////
  2678. // Execute the 'ILLEGAL' instruction 
  2679. ///////////////////////////////////////////////////////////////////////////////
  2680. int m68000::ExecuteILLEGAL(int opcode, String& trace_record, int trace)
  2681. {
  2682.   int status;
  2683.  
  2684.   // Move the PC back to the start of the illegal instruction opcode
  2685.   SetRegister(PC_INDEX, register_value[PC_INDEX]-2, LONG);
  2686.  
  2687.   // Process the illegal instruction exception
  2688.   if((status=ProcessException(4)) != EXECUTE_OK)
  2689.     return(status);
  2690.  
  2691.   if(trace)
  2692.     trace_record+="{Mnemonic {ILLEGAL}} ";
  2693.  
  2694.   return(EXECUTE_OK);
  2695. }
  2696.  
  2697. ///////////////////////////////////////////////////////////////////////////////
  2698. // Execute the 'JMP' instruction
  2699. //////////////////////////////////////////////////////////////////////////////
  2700. int m68000::ExecuteJMP(int opcode, String& trace_record, int trace)
  2701. {
  2702.   int status, in_register_flag;
  2703.   unsigned long address;
  2704.   String ea_description;
  2705.  
  2706.   // Get the effective address
  2707.   if((status=ComputeEffectiveAddress(address, in_register_flag, ea_description,
  2708.                     opcode & 0x3f, LONG, trace)) != EXECUTE_OK)
  2709.   { return(status); }
  2710.  
  2711.   SetRegister(PC_INDEX, address, LONG);
  2712.  
  2713.   if(trace)
  2714.   {
  2715.     trace_record+="{Mnemonic {JMP ";
  2716.     trace_record+=ea_description;
  2717.     trace_record+="}} ";
  2718.   }
  2719.   return(EXECUTE_OK);
  2720. }
  2721.  
  2722. ///////////////////////////////////////////////////////////////////////////////
  2723. // Execute the 'JSR' instruction
  2724. ///////////////////////////////////////////////////////////////////////////////
  2725. int m68000::ExecuteJSR(int opcode, String& trace_record, int trace)
  2726. {
  2727.   int status, in_register_flag;
  2728.   unsigned long address, stack_address;
  2729.   String ea_description;
  2730.  
  2731.   // Get the effective address
  2732.   if((status=ComputeEffectiveAddress(address, in_register_flag, ea_description,
  2733.                     opcode & 0x3f, LONG, trace)) != EXECUTE_OK)
  2734.   { return(status); }
  2735.  
  2736.   // Push the PC onto the stack
  2737.   if(register_value[SR_INDEX] & S_FLAG)
  2738.   {
  2739.     SetRegister(SSP_INDEX, register_value[SSP_INDEX]-4, LONG);
  2740.     stack_address=register_value[SSP_INDEX];
  2741.   }
  2742.   else
  2743.   {
  2744.     SetRegister(USP_INDEX, register_value[USP_INDEX]-4, LONG);
  2745.     stack_address=register_value[USP_INDEX];
  2746.   }
  2747.   if((status=Poke(stack_address,register_value[PC_INDEX],LONG)) != EXECUTE_OK)
  2748.     return(status);
  2749.  
  2750.   SetRegister(PC_INDEX, address, LONG);
  2751.  
  2752.   if(trace)
  2753.   {
  2754.     trace_record+="{Mnemonic {JSR ";
  2755.     trace_record+=ea_description;
  2756.     trace_record+="}} ";
  2757.   }
  2758.   return(EXECUTE_OK);
  2759. }
  2760.  
  2761. ///////////////////////////////////////////////////////////////////////////////
  2762. // Execute the 'LEA' instruction
  2763. ///////////////////////////////////////////////////////////////////////////////
  2764. int m68000::ExecuteLEA(int opcode, String& trace_record, int trace)
  2765. {
  2766.   int status, in_register_flag;
  2767.   unsigned long address, register_number;
  2768.   String ea_description;
  2769.  
  2770.   // Get the effective address
  2771.   if((status=ComputeEffectiveAddress(address, in_register_flag, ea_description,
  2772.                     opcode & 0x3f, LONG, trace)) != EXECUTE_OK)
  2773.   { return(status); }
  2774.  
  2775.   // Get the address register number
  2776.   register_number=A0_INDEX+((opcode&0x0e00) >> 9);
  2777.  
  2778.   // Adjust register_number if it's A7 and we're in supervisor mode
  2779.   if((register_number == USP_INDEX) && (register_value[SR_INDEX] & S_FLAG))
  2780.     register_number = SSP_INDEX;
  2781.  
  2782.   SetRegister(register_number, address, LONG);
  2783.  
  2784.   if(trace)
  2785.   {
  2786.     trace_record+="{Mnemonic {LEA.L ";
  2787.     trace_record+=ea_description;
  2788.     trace_record+=",";
  2789.     trace_record+=register_data[register_number].name;
  2790.     trace_record+="}} ";
  2791.   }
  2792.   return(EXECUTE_OK);
  2793. }
  2794.  
  2795. ///////////////////////////////////////////////////////////////////////////////
  2796. // Execute the 'LINK' instruction 
  2797. ///////////////////////////////////////////////////////////////////////////////
  2798. int m68000::ExecuteLINK(int opcode, String& trace_record, int trace)
  2799. {
  2800.   int status, in_register_flag, register_number, stack_index;
  2801.   unsigned long address;
  2802.   unsigned int displacement;
  2803.   String ea_description;
  2804.  
  2805.   // Get the displacement data pointer
  2806.   if((status=ComputeEffectiveAddress(address, in_register_flag, ea_description,
  2807.                     0x3c, WORD, trace)) != EXECUTE_OK)
  2808.   { return(status); }
  2809.  
  2810.   // Fetch the displacement data
  2811.   if((status=Peek(address, displacement, WORD)) != EXECUTE_OK)
  2812.     return(status);
  2813.   displacement=SignExtend(displacement, WORD);
  2814.  
  2815.   // Get the address register number
  2816.   register_number=A0_INDEX+(opcode&0x0007);
  2817.  
  2818.   // Adjust register_number if it's A7 and we're in supervisor mode
  2819.   if((register_number == USP_INDEX) && (register_value[SR_INDEX] & S_FLAG))
  2820.     register_number = SSP_INDEX;
  2821.  
  2822.   // Get the stack index
  2823.   if(register_value[SR_INDEX]&S_FLAG)
  2824.     stack_index=SSP_INDEX;
  2825.   else
  2826.     stack_index=USP_INDEX;
  2827.  
  2828.   // Push the address register onto the stack
  2829.   SetRegister(stack_index, register_value[stack_index]-4, LONG);
  2830.   if((status=Poke(register_value[stack_index],
  2831.        register_value[register_number], LONG)) != EXECUTE_OK)
  2832.   { return(status); }
  2833.  
  2834.   // Move the stack pointer into the address register
  2835.   SetRegister(register_number, register_value[stack_index], LONG);
  2836.  
  2837.   // Add displacement to the stack pointer
  2838.   SetRegister(stack_index, register_value[stack_index]+displacement, LONG);
  2839.  
  2840.   if(trace)
  2841.   {
  2842.     trace_record+="{Mnemonic {LINK ";
  2843.     trace_record+=register_data[register_number].name;
  2844.     trace_record+=",";
  2845.     trace_record+=ea_description;
  2846.     trace_record+="}} ";
  2847.   }
  2848.   return(EXECUTE_OK);
  2849. }
  2850.  
  2851. ///////////////////////////////////////////////////////////////////////////////
  2852. // Execute the 'LSL' instruction 
  2853. ///////////////////////////////////////////////////////////////////////////////
  2854. int m68000::ExecuteLSL(int opcode, String& trace_record, int trace)
  2855. {
  2856.   int status, size, in_register_flag, shift_count;
  2857.   unsigned long address;
  2858.   unsigned int data;
  2859.   String ea_description;
  2860.  
  2861.   size=(opcode&0x00c0) >> 6;
  2862.  
  2863.   // Check to see if this is a memory or register shift 
  2864.   if(size == 3)
  2865.   {
  2866.     size=WORD;    // Memory always shifts a word
  2867.  
  2868.     // Get the address
  2869.     if((status=ComputeEffectiveAddress(address,in_register_flag,ea_description,
  2870.                  opcode & 0x3f, size, trace)) != EXECUTE_OK)
  2871.     { return(status); }
  2872.  
  2873.     // Fetch the data
  2874.     if((status=Peek(address, data, size)) != EXECUTE_OK)
  2875.       return(status);
  2876.  
  2877.     // Shift the data to the left by one bit.
  2878.     data=data << 1;
  2879.  
  2880.     // Store the shifted data
  2881.     if((status=Poke(address, data, size)) != EXECUTE_OK)
  2882.       return(status);
  2883.  
  2884.     SetConditionCodes(0, 0, data, size,
  2885.         OTHER, N_FLAG|Z_FLAG|X_FLAG|C_FLAG|V_FLAG); 
  2886.     if(data&0x00010000)
  2887.     {
  2888.       register_value[SR_INDEX] |= C_FLAG;
  2889.       register_value[SR_INDEX] |= X_FLAG;
  2890.     }
  2891.   }
  2892.   else
  2893.   {
  2894.     // Compute the shift count
  2895.     if(opcode&32)
  2896.     {
  2897.       shift_count=register_value[D0_INDEX+((opcode&0x0e00) >> 9)] & 0x3f;
  2898.       if(trace)
  2899.         ea_description=register_data[D0_INDEX+((opcode&0x0e00) >> 9)].name;
  2900.     }
  2901.     else
  2902.     {
  2903.       if((shift_count=(opcode&0x0e00) >> 9) == 0)
  2904.         shift_count=8;
  2905.  
  2906.       if(trace)
  2907.       {
  2908.         ea_description="#$";
  2909.         ea_description+=IntToString(shift_count,1);
  2910.       }
  2911.     }
  2912.  
  2913.     if(trace)
  2914.     {
  2915.       ea_description+=",";
  2916.       ea_description+=register_data[D0_INDEX+(opcode&7)].name;
  2917.     }
  2918.  
  2919.     unsigned int carry;
  2920.     unsigned int carry_mask;
  2921.  
  2922.     // Setup masks
  2923.     if(size==BYTE)
  2924.       carry_mask=0x80;
  2925.     else if(size==WORD)
  2926.       carry_mask=0x8000;
  2927.     else
  2928.       carry_mask=0x80000000;
  2929.  
  2930.     // Perform the shift on the data
  2931.     data=register_value[D0_INDEX+(opcode&7)];
  2932.     for(int t=0;t<shift_count;++t)
  2933.     {
  2934.       carry=data & carry_mask;
  2935.       data=data << 1;
  2936.     }
  2937.  
  2938.     SetRegister(D0_INDEX+(opcode&7), data, size);
  2939.  
  2940.     SetConditionCodes(0, 0, data, size,
  2941.         OTHER, N_FLAG|Z_FLAG|X_FLAG|C_FLAG|V_FLAG); 
  2942.     if(carry)
  2943.     {
  2944.       register_value[SR_INDEX] |= C_FLAG;
  2945.       register_value[SR_INDEX] |= X_FLAG;
  2946.     }
  2947.   }
  2948.  
  2949.   if (trace)
  2950.   {
  2951.     trace_record+="{Mnemonic {LSL";
  2952.     if(size==BYTE)
  2953.       trace_record+=".B ";
  2954.     else if(size==WORD)
  2955.       trace_record+=".W ";
  2956.     else if(size==LONG)
  2957.       trace_record+=".L ";
  2958.     trace_record+=ea_description;
  2959.     trace_record+="}} ";
  2960.   }
  2961.   return(EXECUTE_OK);
  2962. }
  2963.  
  2964. ///////////////////////////////////////////////////////////////////////////////
  2965. // Execute the 'LSR' instruction 
  2966. ///////////////////////////////////////////////////////////////////////////////
  2967. int m68000::ExecuteLSR(int opcode, String& trace_record, int trace)
  2968. {
  2969.   int status, size, in_register_flag, shift_count;
  2970.   unsigned long address;
  2971.   unsigned int data;
  2972.   String ea_description;
  2973.  
  2974.   size=(opcode&0x00c0) >> 6;
  2975.  
  2976.   // Check to see if this is a memory or register shift
  2977.   if(size == 3)
  2978.   {
  2979.     size=WORD;    // Memory always shifts a word
  2980.  
  2981.     // Get the address
  2982.     if((status=ComputeEffectiveAddress(address,in_register_flag,ea_description,
  2983.                  opcode & 0x3f, size, trace)) != EXECUTE_OK)
  2984.     { return(status); }
  2985.  
  2986.     // Fetch the data
  2987.     if((status=Peek(address, data, size)) != EXECUTE_OK)
  2988.       return(status);
  2989.  
  2990.     // Set the condition codes
  2991.     SetConditionCodes(0, 0, (data >> 1) & 0x7fff, size,
  2992.         OTHER, N_FLAG|Z_FLAG|X_FLAG|C_FLAG|V_FLAG); 
  2993.     if(data & 0x0001)
  2994.     {
  2995.       register_value[SR_INDEX] |= C_FLAG;
  2996.       register_value[SR_INDEX] |= X_FLAG;
  2997.     }
  2998.  
  2999.     // Shift the data to the right by one bit.
  3000.     data=(data >> 1) & 0x7fff;
  3001.  
  3002.     // Store the shifted data
  3003.     if((status=Poke(address, data, size)) != EXECUTE_OK)
  3004.       return(status);
  3005.   }
  3006.   else
  3007.   {
  3008.     // Compute the shift count
  3009.     if(opcode&32)
  3010.     {
  3011.       shift_count=register_value[D0_INDEX+((opcode&0x0e00) >> 9)] & 0x3f;
  3012.       if(trace)
  3013.         ea_description=register_data[D0_INDEX+((opcode&0x0e00) >> 9)].name;
  3014.     }
  3015.     else
  3016.     {
  3017.       if((shift_count=(opcode&0x0e00) >> 9) == 0)
  3018.         shift_count=8;
  3019.  
  3020.       if(trace)
  3021.       {
  3022.         ea_description="#$";
  3023.         ea_description+=IntToString(shift_count,1);
  3024.       }
  3025.     }
  3026.  
  3027.     if(trace)
  3028.     {
  3029.       ea_description+=",";
  3030.       ea_description+=register_data[D0_INDEX+(opcode&7)].name;
  3031.     }
  3032.  
  3033.     unsigned int carry, clear_mask;
  3034.  
  3035.     // Setup masks
  3036.     if(size==BYTE)
  3037.       clear_mask=0x7f;
  3038.     else if(size==WORD)
  3039.       clear_mask=0x7fff;
  3040.     else
  3041.       clear_mask=0x7fffffff;
  3042.  
  3043.     // Perform the shift on the data
  3044.     data=register_value[D0_INDEX+(opcode&7)];
  3045.     for(int t=0;t<shift_count;++t)
  3046.     {
  3047.       carry=data & 0x00000001;
  3048.       data=(data >> 1) & clear_mask;
  3049.     }
  3050.  
  3051.     SetRegister(D0_INDEX+(opcode&7), data, size);
  3052.  
  3053.     SetConditionCodes(0, 0, data, size,
  3054.         OTHER, N_FLAG|Z_FLAG|X_FLAG|C_FLAG|V_FLAG); 
  3055.     if(carry)
  3056.     {
  3057.       register_value[SR_INDEX] |= C_FLAG;
  3058.       register_value[SR_INDEX] |= X_FLAG;
  3059.     }
  3060.   }
  3061.  
  3062.   if (trace)
  3063.   {
  3064.     trace_record+="{Mnemonic {LSR";
  3065.     if(size==BYTE)
  3066.       trace_record+=".B ";
  3067.     else if(size==WORD)
  3068.       trace_record+=".W ";
  3069.     else if(size==LONG)
  3070.       trace_record+=".L ";
  3071.     trace_record+=ea_description;
  3072.     trace_record+="}} ";
  3073.   }
  3074.   return(EXECUTE_OK);
  3075. }
  3076.  
  3077. ///////////////////////////////////////////////////////////////////////////////
  3078. // Execute the 'MOVE' instruction
  3079. ///////////////////////////////////////////////////////////////////////////////
  3080. int m68000::ExecuteMOVE(int opcode, String& trace_record, int trace)
  3081. {
  3082.   int status, in_register_flag, size;
  3083.   unsigned long src_address, dest_address;
  3084.   unsigned int src;
  3085.   String ea_description;
  3086.  
  3087.   switch ((opcode&0x3000)>>12)
  3088.   {
  3089.     case 1:
  3090.       size=BYTE;
  3091.       break;
  3092.     case 3:
  3093.       size=WORD;
  3094.       break;
  3095.     case 2:
  3096.       size=LONG;
  3097.       break;
  3098.   }
  3099.  
  3100.   // Get the source effective address
  3101.   if((status=ComputeEffectiveAddress(src_address, in_register_flag,
  3102.                     ea_description, opcode & 0x3f, size, trace)) != EXECUTE_OK)
  3103.   { return(status); }
  3104.  
  3105.   if(in_register_flag)
  3106.     src=register_value[src_address];
  3107.   else
  3108.     if((status=Peek(src_address, src, size)) != EXECUTE_OK)
  3109.       return(status);
  3110.  
  3111.   if(trace) ea_description+=",";
  3112.  
  3113.   // Get the destination effective address
  3114.   if((status=ComputeEffectiveAddress(dest_address, in_register_flag,
  3115.                     ea_description, ((opcode&0x01c0)>>3)|((opcode&0x0e00)>>9),
  3116.                     size, trace)) != EXECUTE_OK)
  3117.   { return(status); }
  3118.  
  3119.   if(in_register_flag)
  3120.     SetRegister(dest_address, src, size);
  3121.   else
  3122.     if((status=Poke(dest_address, src, size)) != EXECUTE_OK)
  3123.       return(status);
  3124.  
  3125.   SetConditionCodes(0, 0, src, size, OTHER,
  3126.                     N_FLAG|Z_FLAG|V_FLAG|C_FLAG);
  3127.   if(trace)
  3128.   {
  3129.     trace_record+="{Mnemonic {MOVE";
  3130.     if (size==BYTE)
  3131.       trace_record+=".B ";
  3132.     else if (size==WORD)
  3133.       trace_record+=".W ";
  3134.     else if (size==LONG)
  3135.       trace_record+=".L ";
  3136.     trace_record+=ea_description;
  3137.     trace_record+="}} ";
  3138.   }
  3139.   return(EXECUTE_OK);
  3140. }
  3141.  
  3142. ///////////////////////////////////////////////////////////////////////////////
  3143. // Execute the 'MOVEA' instruction
  3144. ///////////////////////////////////////////////////////////////////////////////
  3145. int m68000::ExecuteMOVEA(int opcode, String& trace_record, int trace)
  3146. {
  3147.   int status, in_register_flag, size;
  3148.   unsigned long src_address, dest_address;
  3149.   unsigned int src;
  3150.   String ea_description;
  3151.  
  3152.   switch ((opcode&0x3000)>>12)
  3153.   {
  3154.     case 3:
  3155.       size=WORD;
  3156.       break;
  3157.     case 2:
  3158.       size=LONG;
  3159.       break;
  3160.   }
  3161.  
  3162.   // Get the source effective address
  3163.   if((status=ComputeEffectiveAddress(src_address, in_register_flag,
  3164.                     ea_description, opcode & 0x3f, size, trace)) != EXECUTE_OK)
  3165.   { return(status); }
  3166.  
  3167.   if(in_register_flag)
  3168.     src=register_value[src_address];
  3169.   else
  3170.     if((status=Peek(src_address, src, size)) != EXECUTE_OK)
  3171.       return(status);
  3172.  
  3173.   if(size==WORD)
  3174.     src=SignExtend(src,WORD);
  3175.  
  3176.   if(trace) ea_description+=",";
  3177.  
  3178.   // Get the destination effective address
  3179.   if((status=ComputeEffectiveAddress(dest_address, in_register_flag,
  3180.                     ea_description, ((opcode&0x01c0)>>3)|((opcode&0x0e00)>>9),
  3181.                     LONG, trace)) != EXECUTE_OK)
  3182.   { return(status); }
  3183.  
  3184.   if(in_register_flag)
  3185.     SetRegister(dest_address, src, LONG);
  3186.   else
  3187.     if((status=Poke(dest_address, src, LONG)) != EXECUTE_OK)
  3188.       return(status);
  3189.  
  3190.   if(trace)
  3191.   {
  3192.     trace_record+="{Mnemonic {MOVEA";
  3193.     if (size==WORD)
  3194.       trace_record+=".W ";
  3195.     else if (size==LONG)
  3196.       trace_record+=".L ";
  3197.     trace_record+=ea_description;
  3198.     trace_record+="}} ";
  3199.   }
  3200.   return(EXECUTE_OK);
  3201. }
  3202.  
  3203. ///////////////////////////////////////////////////////////////////////////////
  3204. // Execute the 'MOVEM' instruction
  3205. ///////////////////////////////////////////////////////////////////////////////
  3206. int m68000::ExecuteMOVEM(int opcode, String& trace_record, int trace)
  3207. {
  3208.   int status, in_register_flag, size;
  3209.   unsigned long address, offset, reg;
  3210.   unsigned int list, data;
  3211.   String ea_description, mnemonic;
  3212.  
  3213.   // Determine size and offset
  3214.   if(opcode&64)
  3215.   {
  3216.     offset=4;
  3217.     size=LONG;
  3218.   }
  3219.   else
  3220.   {
  3221.     offset=2;
  3222.     size=WORD;
  3223.   }
  3224.  
  3225.   if(trace)
  3226.   {
  3227.     mnemonic+="{Mnemonic {MOVEM";
  3228.     if (size==WORD)
  3229.       mnemonic+=".W ";
  3230.     else if (size==LONG)
  3231.       mnemonic+=".L ";
  3232.   }
  3233.  
  3234.   // Get the register list mask
  3235.   if((status=Peek(register_value[PC_INDEX], list, WORD)) != EXECUTE_OK)
  3236.     return(status);
  3237.   SetRegister(PC_INDEX, register_value[PC_INDEX]+2, LONG);
  3238.  
  3239.   // Get the effective address (if this isn't predecrement)
  3240.   if((opcode&0x38)!=32)
  3241.   {
  3242.     if((status=ComputeEffectiveAddress(address, in_register_flag,
  3243.                 ea_description, opcode & 0x3f, size, trace)) != EXECUTE_OK)
  3244.     { return(status); }
  3245.   }
  3246.  
  3247.   if((opcode&0x38)==32)    // Predecrement mode
  3248.   {
  3249.     if((register_value[SR_INDEX]&S_FLAG) && ((A0_INDEX+(opcode&7))==USP_INDEX))
  3250.       reg=SSP_INDEX;
  3251.     else
  3252.       reg=A0_INDEX+(opcode&7);
  3253.     address=register_value[reg];
  3254.     if(trace)
  3255.     {
  3256.       ea_description+="-(";
  3257.       ea_description+=register_data[reg].name;
  3258.       ea_description+=")";
  3259.     }
  3260.  
  3261.     for(int t=A0_INDEX+7;t>=D0_INDEX;--t)
  3262.     {
  3263.       if(list & (1 << (A0_INDEX+7-t)))
  3264.       {
  3265.         if((register_value[SR_INDEX]&S_FLAG) && (t==USP_INDEX))
  3266.           reg=SSP_INDEX;
  3267.         else
  3268.           reg=t;
  3269.  
  3270.         address -= offset;
  3271.         if((status=Poke(address, register_value[reg], size)) != EXECUTE_OK)
  3272.           return(status);
  3273.  
  3274.         if(trace)
  3275.         {
  3276.           mnemonic+=register_data[reg].name;
  3277.           mnemonic+=" ";
  3278.         }
  3279.       }
  3280.     }
  3281.     if(trace)
  3282.     {
  3283.       mnemonic+=",";
  3284.       mnemonic+=ea_description;
  3285.     }
  3286.   }
  3287.   else    // Postincrement or Control mode
  3288.   {
  3289.     if(trace)
  3290.     {
  3291.       mnemonic+=ea_description;
  3292.       mnemonic+=",";
  3293.     }
  3294.     for(int t=D0_INDEX;t<=A0_INDEX+7;++t)
  3295.     {
  3296.       if(list & (1 << (t-D0_INDEX)))
  3297.       {
  3298.         if((register_value[SR_INDEX]&S_FLAG) && (t==USP_INDEX))
  3299.           reg=SSP_INDEX;
  3300.         else
  3301.           reg=t;
  3302.  
  3303.         if(opcode&1024)
  3304.         {
  3305.           if((status=Peek(address, data, size)) != EXECUTE_OK)
  3306.             return(status);
  3307.           SetRegister(reg, data, size);
  3308.         }
  3309.         else
  3310.         {
  3311.           if((status=Poke(address, register_value[reg], size)) != EXECUTE_OK)
  3312.             return(status);
  3313.         }
  3314.         address += offset;
  3315.  
  3316.         if(trace)
  3317.         {
  3318.           mnemonic+=register_data[reg].name;
  3319.           mnemonic+=" ";
  3320.         }
  3321.       }
  3322.     }
  3323.   }
  3324.  
  3325.   if(((opcode&0x38)==32) || ((opcode&0x38)==24))
  3326.   {
  3327.     if((register_value[SR_INDEX]&S_FLAG) && ((opcode&7)==7))
  3328.       SetRegister(SSP_INDEX, address, LONG);
  3329.     else
  3330.       SetRegister(A0_INDEX+(opcode&7), address, LONG);
  3331.   }
  3332.  
  3333.   if(trace)
  3334.   {
  3335.     mnemonic+="}} ";
  3336.     trace_record+=mnemonic;
  3337.   }
  3338.   return(EXECUTE_OK);
  3339. }
  3340.  
  3341. ///////////////////////////////////////////////////////////////////////////////
  3342. // Execute the '' instruction 
  3343. ///////////////////////////////////////////////////////////////////////////////
  3344. int m68000::ExecuteMOVEP(int opcode, String& trace_record, int trace)
  3345. {
  3346.   return(ExecuteInvalid(opcode, trace_record, trace));
  3347. }
  3348.  
  3349. ///////////////////////////////////////////////////////////////////////////////
  3350. // Execute the 'MOVEQ' instruction
  3351. ///////////////////////////////////////////////////////////////////////////////
  3352. int m68000::ExecuteMOVEQ(int opcode, String& trace_record, int trace)
  3353. {
  3354.   unsigned long register_number;
  3355.   unsigned int data;
  3356.  
  3357.   // Get the destination data register number
  3358.   register_number=D0_INDEX+(opcode & 0x0e00) >> 9;
  3359.  
  3360.   // Get the immediate data
  3361.   data=SignExtend((opcode & 0xff), BYTE);
  3362.  
  3363.   SetConditionCodes(0, 0, data, LONG, OTHER, C_FLAG|V_FLAG|Z_FLAG|N_FLAG);
  3364.   SetRegister(register_number, data, LONG);
  3365.  
  3366.   if (trace)
  3367.   {
  3368.     trace_record+="{Mnemonic {MOVEQ.L #$";
  3369.     trace_record+=IntToString(data,2);
  3370.     trace_record+=",";
  3371.     trace_record+=register_data[register_number].name;
  3372.     trace_record+="}} ";
  3373.   }
  3374.   return(EXECUTE_OK);
  3375. }
  3376.  
  3377. ///////////////////////////////////////////////////////////////////////////////
  3378. // Execute the 'MOVEfromSR' instruction 
  3379. ///////////////////////////////////////////////////////////////////////////////
  3380. int m68000::ExecuteMOVEfromSR(int opcode, String& trace_record, int trace)
  3381. {
  3382.   int status, in_register;
  3383.   unsigned long address;
  3384.   String ea_description;
  3385.  
  3386.   // Get the destination data pointer
  3387.   if((status=ComputeEffectiveAddress(address, in_register, ea_description,
  3388.                  opcode & 0x3f, WORD, trace)) != EXECUTE_OK)
  3389.   { return(status); }
  3390.  
  3391.   if(in_register)
  3392.     SetRegister(address, register_value[SR_INDEX], WORD);
  3393.   else
  3394.     if((status=Poke(address, register_value[SR_INDEX], WORD)) != EXECUTE_OK)
  3395.       return(status);
  3396.  
  3397.   if (trace)
  3398.   {
  3399.     trace_record+="{Mnemonic {MOVE.W SR,";
  3400.     trace_record+=ea_description;
  3401.     trace_record+="}} ";
  3402.   }
  3403.   return(EXECUTE_OK);
  3404. }
  3405.  
  3406. ///////////////////////////////////////////////////////////////////////////////
  3407. // Execute the 'MOVEUSP' instruction 
  3408. ///////////////////////////////////////////////////////////////////////////////
  3409. int m68000::ExecuteMOVEUSP(int opcode, String& trace_record, int trace)
  3410. {
  3411.   int status, register_number;
  3412.   String ea_description;
  3413.  
  3414.   // Make sure we're in supervisor mode or trap
  3415.   if (!(register_value[SR_INDEX] & S_FLAG))
  3416.   {
  3417.     SetRegister(PC_INDEX, register_value[PC_INDEX]-2, LONG);
  3418.     if((status=ProcessException(8)) != EXECUTE_OK)
  3419.       return(status);
  3420.     if(trace);
  3421.       trace_record+="{Mnemonic {Privilege Violation Exception}} ";
  3422.     return(EXECUTE_PRIVILEGED_OK);
  3423.   }
  3424.  
  3425.   // Get the address register index
  3426.   if((opcode&7) == 7)
  3427.     register_number=SSP_INDEX;
  3428.   else 
  3429.     register_number=A0_INDEX+(opcode&7);
  3430.  
  3431.   // Move from or to the USP
  3432.   if(opcode & 8)
  3433.   {
  3434.     SetRegister(register_number, register_value[USP_INDEX], LONG);
  3435.     if(trace)
  3436.     {
  3437.       ea_description="USP,";
  3438.       ea_description+=register_data[register_number].name;
  3439.     }
  3440.   } 
  3441.   else
  3442.   {
  3443.     SetRegister(USP_INDEX, register_value[register_number], LONG);
  3444.     if(trace)
  3445.     {
  3446.       ea_description=register_data[register_number].name;
  3447.       ea_description+=",USP";
  3448.     }
  3449.   }
  3450.  
  3451.   if(trace)
  3452.   {
  3453.     trace_record+="{Mnemonic {MOVE.L ";
  3454.     trace_record+=ea_description;
  3455.     trace_record+="}} ";
  3456.   }
  3457.   return(EXECUTE_PRIVILEGED_OK);
  3458. }
  3459.  
  3460. ///////////////////////////////////////////////////////////////////////////////
  3461. // Execute the 'MOVEtoCCR' instruction 
  3462. ///////////////////////////////////////////////////////////////////////////////
  3463. int m68000::ExecuteMOVEtoCCR(int opcode, String& trace_record, int trace)
  3464. {
  3465.   int status, in_register;
  3466.   unsigned long address;
  3467.   unsigned int data;
  3468.   String ea_description;
  3469.  
  3470.   // Get the destination data pointer
  3471.   if((status=ComputeEffectiveAddress(address, in_register, ea_description,
  3472.                  opcode & 0x3f, WORD, trace)) != EXECUTE_OK)
  3473.   { return(status); }
  3474.  
  3475.   if(in_register)
  3476.     data=register_value[address];
  3477.   else
  3478.     if((status=Peek(address, data, WORD)) != EXECUTE_OK)
  3479.       return(status);
  3480.  
  3481.   SetRegister(SR_INDEX, data, BYTE);
  3482.  
  3483.   if (trace)
  3484.   {
  3485.     trace_record+="{Mnemonic {MOVE.W ";
  3486.     trace_record+=ea_description;
  3487.     trace_record+=",CCR}} ";
  3488.   }
  3489.   return(EXECUTE_OK);
  3490. }
  3491.  
  3492. ///////////////////////////////////////////////////////////////////////////////
  3493. // Execute the 'MOVEtoSR' instruction 
  3494. ///////////////////////////////////////////////////////////////////////////////
  3495. int m68000::ExecuteMOVEtoSR(int opcode, String& trace_record, int trace)
  3496. {
  3497.   int status, in_register;
  3498.   unsigned long address;
  3499.   unsigned int data;
  3500.   String ea_description;
  3501.  
  3502.   // Make sure we're in supervisor mode or trap
  3503.   if (!(register_value[SR_INDEX] & S_FLAG))
  3504.   {
  3505.     SetRegister(PC_INDEX, register_value[PC_INDEX]-2, LONG);
  3506.     if((status=ProcessException(8)) != EXECUTE_OK)
  3507.       return(status);
  3508.     if(trace);
  3509.       trace_record+="{Mnemonic {Privilege Violation Exception}} ";
  3510.     return(EXECUTE_PRIVILEGED_OK);
  3511.   }
  3512.  
  3513.   // Get the destination data pointer
  3514.   if((status=ComputeEffectiveAddress(address, in_register, ea_description,
  3515.                  opcode & 0x3f, WORD, trace)) != EXECUTE_OK)
  3516.   { return(status); }
  3517.  
  3518.   if(in_register)
  3519.     data=register_value[address];
  3520.   else
  3521.     if((status=Peek(address, data, WORD)) != EXECUTE_OK)
  3522.       return(status);
  3523.  
  3524.   SetRegister(SR_INDEX, data, WORD);
  3525.  
  3526.   if (trace)
  3527.   {
  3528.     trace_record+="{Mnemonic {MOVE.W ";
  3529.     trace_record+=ea_description;
  3530.     trace_record+=",SR}} ";
  3531.   }
  3532.   return(EXECUTE_PRIVILEGED_OK);
  3533. }
  3534.  
  3535. ///////////////////////////////////////////////////////////////////////////////
  3536. // Execute the 'MULS' instruction 
  3537. ///////////////////////////////////////////////////////////////////////////////
  3538. int m68000::ExecuteMULS(int opcode, String& trace_record, int trace)
  3539. {
  3540.   int status, in_register_flag;
  3541.   unsigned long ea_address, register_number;
  3542.   unsigned int ea_data;
  3543.   int result, data;
  3544.   String ea_description;
  3545.  
  3546.   // Get the <ea> data address
  3547.   if((status=ComputeEffectiveAddress(ea_address, in_register_flag,
  3548.                  ea_description, opcode & 0x3f, WORD, trace)) != EXECUTE_OK)
  3549.   { return(status); }
  3550.  
  3551.   // Fetch the <ea> data
  3552.   if(in_register_flag)
  3553.     ea_data=register_value[ea_address];
  3554.   else
  3555.     if((status=Peek(ea_address, ea_data, WORD)) != EXECUTE_OK)
  3556.       return(status);
  3557.  
  3558.   // Get the register number
  3559.   register_number=D0_INDEX+((opcode&0x0e00) >> 9);
  3560.   data=register_value[register_number];
  3561.  
  3562.   // Sign extend operands
  3563.   data=SignExtend(data,WORD);
  3564.   ea_data=SignExtend(ea_data,WORD);
  3565.  
  3566.   result=data*ea_data;
  3567.   SetConditionCodes(0, 0, result, LONG, OTHER, V_FLAG|C_FLAG|Z_FLAG|N_FLAG);
  3568.   SetRegister(register_number, result, LONG);
  3569.  
  3570.   if(trace)
  3571.   {
  3572.     trace_record+="{Mnemonic {MULS.W ";
  3573.     trace_record+=ea_description;
  3574.     trace_record+=",";
  3575.     trace_record+=register_data[register_number].name;
  3576.     trace_record+="}} ";
  3577.   }
  3578.   return(EXECUTE_OK);
  3579. }
  3580.  
  3581. ///////////////////////////////////////////////////////////////////////////////
  3582. // Execute the 'MULU' instruction 
  3583. ///////////////////////////////////////////////////////////////////////////////
  3584. int m68000::ExecuteMULU(int opcode, String& trace_record, int trace)
  3585. {
  3586.   int status, in_register_flag;
  3587.   unsigned long ea_address, register_number;
  3588.   unsigned int result, ea_data;
  3589.   String ea_description;
  3590.  
  3591.   // Get the <ea> data address
  3592.   if((status=ComputeEffectiveAddress(ea_address, in_register_flag,
  3593.                  ea_description, opcode & 0x3f, WORD, trace)) != EXECUTE_OK)
  3594.   { return(status); }
  3595.  
  3596.   // Fetch the <ea> data
  3597.   if(in_register_flag)
  3598.     ea_data=register_value[ea_address]&0xffff;
  3599.   else
  3600.     if((status=Peek(ea_address, ea_data, WORD)) != EXECUTE_OK)
  3601.       return(status);
  3602.  
  3603.   // Get the register number
  3604.   register_number=D0_INDEX+((opcode&0x0e00) >> 9);
  3605.  
  3606.   result=(register_value[register_number]&0xffff)*ea_data;
  3607.   SetConditionCodes(0, 0, result, LONG, OTHER, V_FLAG|C_FLAG|Z_FLAG|N_FLAG);
  3608.   SetRegister(register_number, result, LONG);
  3609.  
  3610.   if(trace)
  3611.   {
  3612.     trace_record+="{Mnemonic {MULU.W ";
  3613.     trace_record+=ea_description;
  3614.     trace_record+=",";
  3615.     trace_record+=register_data[register_number].name;
  3616.     trace_record+="}} ";
  3617.   }
  3618.   return(EXECUTE_OK);
  3619. }
  3620.  
  3621. ///////////////////////////////////////////////////////////////////////////////
  3622. // Execute the '' instruction 
  3623. ///////////////////////////////////////////////////////////////////////////////
  3624. int m68000::ExecuteNBCD(int opcode, String& trace_record, int trace)
  3625. {
  3626.   return(ExecuteInvalid(opcode, trace_record, trace));
  3627. }
  3628.  
  3629. ///////////////////////////////////////////////////////////////////////////////
  3630. // Execute the 'NEG' instruction 
  3631. ///////////////////////////////////////////////////////////////////////////////
  3632. int m68000::ExecuteNEG(int opcode, String& trace_record, int trace)
  3633. {
  3634.   int status, size, in_register_flag;
  3635.   unsigned long address;
  3636.   unsigned int data, result;
  3637.   String ea_description;
  3638.  
  3639.   size=((opcode&0x00c0) >> 6);
  3640.  
  3641.   // Get the effective address
  3642.   if((status=ComputeEffectiveAddress(address, in_register_flag, ea_description,
  3643.                     opcode & 0x3f, size, trace)) != EXECUTE_OK)
  3644.   { return(status); }
  3645.  
  3646.   // Fetch the data
  3647.   if(in_register_flag)
  3648.     data=register_value[address];
  3649.   else
  3650.     if((status=Peek(address, data, size)) != EXECUTE_OK)
  3651.       return(status);
  3652.  
  3653.   data = SignExtend(data, size);
  3654.   result = 0-data;
  3655.   SetConditionCodes(data, 0, result, size,
  3656.                     SUBTRACTION, C_FLAG|X_FLAG|V_FLAG|Z_FLAG|N_FLAG);
  3657.  
  3658.   // Store the result  
  3659.   if(in_register_flag)
  3660.     SetRegister(address, result, size);
  3661.   else
  3662.     if((status=Poke(address, result, size)) != EXECUTE_OK)
  3663.       return(status);
  3664.  
  3665.   if(trace)
  3666.   {
  3667.     trace_record+="{Mnemonic {NEG";
  3668.     if (size==BYTE)
  3669.       trace_record+=".B ";
  3670.     else if (size==WORD)
  3671.       trace_record+=".W ";
  3672.     else if (size==LONG)
  3673.       trace_record+=".L ";
  3674.     trace_record+=ea_description;
  3675.     trace_record+="}} ";
  3676.   }
  3677.   return(EXECUTE_OK);
  3678. }
  3679.  
  3680. ///////////////////////////////////////////////////////////////////////////////
  3681. // Execute the 'NEGX' instruction 
  3682. ///////////////////////////////////////////////////////////////////////////////
  3683. int m68000::ExecuteNEGX(int opcode, String& trace_record, int trace)
  3684. {
  3685.   int status, size, in_register_flag;
  3686.   unsigned long address;
  3687.   unsigned int data, result;
  3688.   String ea_description;
  3689.  
  3690.   size=((opcode&0x00c0) >> 6);
  3691.  
  3692.   // Get the effective address
  3693.   if((status=ComputeEffectiveAddress(address, in_register_flag, ea_description,
  3694.                  opcode & 0x3f, size, trace)) != EXECUTE_OK)
  3695.   { return(status); }
  3696.  
  3697.   // Fetch the data
  3698.   if(in_register_flag)
  3699.     data=register_value[address];
  3700.   else
  3701.     if((status=Peek(address, data, size)) != EXECUTE_OK)
  3702.       return(status);
  3703.  
  3704.   data = SignExtend(data, size);
  3705.  
  3706.   if(register_value[SR_INDEX] & X_FLAG)
  3707.     result=0-data-1;
  3708.   else
  3709.     result=0-data;
  3710.  
  3711.   SetConditionCodes(data, 0, result, size,
  3712.                     SUBTRACTION, C_FLAG|X_FLAG|V_FLAG|N_FLAG);
  3713.   if (size==BYTE)
  3714.     result=result&0xff;
  3715.   else if (size==WORD)
  3716.     result=result&0xffff;
  3717.   else if (size==LONG)
  3718.     result=result&0xffffffff;
  3719.  
  3720.   if(result)
  3721.     register_value[SR_INDEX] &= ~Z_FLAG;
  3722.  
  3723.   // Store the result  
  3724.   if(in_register_flag)
  3725.     SetRegister(address, result, size);
  3726.   else
  3727.     if((status=Poke(address, result, size)) != EXECUTE_OK)
  3728.       return(status);
  3729.  
  3730.   if(trace)
  3731.   {
  3732.     trace_record+="{Mnemonic {NEGX";
  3733.     if (size==BYTE)
  3734.       trace_record+=".B ";
  3735.     else if (size==WORD)
  3736.       trace_record+=".W ";
  3737.     else if (size==LONG)
  3738.       trace_record+=".L ";
  3739.     trace_record+=ea_description;
  3740.     trace_record+="}} ";
  3741.   }
  3742.   return(EXECUTE_OK);
  3743. }
  3744.  
  3745. ///////////////////////////////////////////////////////////////////////////////
  3746. // Execute the 'NOP' instruction  (An instruction I like :-)
  3747. ///////////////////////////////////////////////////////////////////////////////
  3748. int m68000::ExecuteNOP(int opcode, String& trace_record, int trace)
  3749. {
  3750.   if(trace)
  3751.     trace_record+="{Mnemonic {NOP}}";
  3752.  
  3753.   return(EXECUTE_OK);
  3754. }
  3755.  
  3756. ///////////////////////////////////////////////////////////////////////////////
  3757. // Execute the 'NOT' instruction 
  3758. ///////////////////////////////////////////////////////////////////////////////
  3759. int m68000::ExecuteNOT(int opcode, String& trace_record, int trace)
  3760. {
  3761.   int status, size, in_register_flag;
  3762.   unsigned long address;
  3763.   unsigned int data, result;
  3764.   String ea_description;
  3765.  
  3766.   size=((opcode&0x00c0) >> 6);
  3767.  
  3768.   // Get the effective address
  3769.   if((status=ComputeEffectiveAddress(address, in_register_flag, ea_description,
  3770.                     opcode & 0x3f, size, trace)) != EXECUTE_OK)
  3771.   { return(status); }
  3772.  
  3773.   // Fetch the data
  3774.   if(in_register_flag)
  3775.     data=register_value[address];
  3776.   else
  3777.     if((status=Peek(address, data, size)) != EXECUTE_OK)
  3778.       return(status);
  3779.  
  3780.   result = ~data;
  3781.   SetConditionCodes(data, 0, result, size,
  3782.                     OTHER, C_FLAG|V_FLAG|Z_FLAG|N_FLAG);
  3783.  
  3784.   // Store the result  
  3785.   if(in_register_flag)
  3786.     SetRegister(address, result, size);
  3787.   else
  3788.     if((status=Poke(address, result, size)) != EXECUTE_OK)
  3789.       return(status);
  3790.  
  3791.   if(trace)
  3792.   {
  3793.     trace_record+="{Mnemonic {NOT";
  3794.     if (size==BYTE)
  3795.       trace_record+=".B ";
  3796.     else if (size==WORD)
  3797.       trace_record+=".W ";
  3798.     else if (size==LONG)
  3799.       trace_record+=".L ";
  3800.     trace_record+=ea_description;
  3801.     trace_record+="}} ";
  3802.   }
  3803.   return(EXECUTE_OK);
  3804. }
  3805.  
  3806. ///////////////////////////////////////////////////////////////////////////////
  3807. // Execute the 'OR' instruction 
  3808. ///////////////////////////////////////////////////////////////////////////////
  3809. int m68000::ExecuteOR(int opcode, String& trace_record, int trace)
  3810. {
  3811.   int status, size, in_register_flag;
  3812.   unsigned long ea_address, register_number;
  3813.   unsigned int result, ea_data;
  3814.   String mnemonic, ea_description;
  3815.  
  3816.   size=(opcode&0x00c0) >> 6;
  3817.  
  3818.   // Get the <ea> data address
  3819.   if((status=ComputeEffectiveAddress(ea_address, in_register_flag,
  3820.                   ea_description, opcode & 0x3f, size, trace)) != EXECUTE_OK)
  3821.   { return(status); }
  3822.  
  3823.   // Fetch the <ea> data 
  3824.   if(in_register_flag)
  3825.     ea_data=register_value[ea_address];
  3826.   else
  3827.     if((status=Peek(ea_address, ea_data, size)) != EXECUTE_OK)
  3828.       return(status);
  3829.  
  3830.   // Get the register number
  3831.   register_number=D0_INDEX+((opcode&0x0e00) >> 9);
  3832.  
  3833.   if(trace)
  3834.   {
  3835.     mnemonic+="{Mnemonic {OR";
  3836.     if (size==BYTE)
  3837.       mnemonic+=".B ";
  3838.     else if (size==WORD)
  3839.       mnemonic+=".W ";
  3840.     else if (size==LONG)
  3841.       mnemonic+=".L ";
  3842.   }
  3843.  
  3844.   if(opcode & 0x0100)    // <Dn> | <ea> -> <ea>
  3845.   {
  3846.     if(trace)
  3847.     {
  3848.       mnemonic+=register_data[register_number].name;
  3849.       mnemonic+=",";
  3850.       mnemonic+=ea_description;
  3851.     }
  3852.     result=register_value[register_number]|ea_data;
  3853.     SetConditionCodes(register_value[register_number], ea_data, result, size,
  3854.                       OTHER, V_FLAG|C_FLAG|Z_FLAG|N_FLAG);
  3855.     if((status=Poke(ea_address, result, size)) != EXECUTE_OK)
  3856.       return(status);
  3857.   }
  3858.   else                   // <ea> | <Dn> -> <Dn>
  3859.   {
  3860.     if(trace)
  3861.     {
  3862.       mnemonic+=ea_description;
  3863.       mnemonic+=",";
  3864.       mnemonic+=register_data[register_number].name;
  3865.     }
  3866.     result=ea_data|register_value[register_number];
  3867.     SetConditionCodes(ea_data, register_value[register_number], result, size,
  3868.                       OTHER, V_FLAG|C_FLAG|Z_FLAG|N_FLAG);
  3869.     SetRegister(register_number, result, size);
  3870.   }
  3871.  
  3872.   if(trace)
  3873.   {
  3874.     mnemonic+="}} ";
  3875.     trace_record+=mnemonic;
  3876.   }
  3877.   return(EXECUTE_OK);
  3878. }
  3879.  
  3880. ///////////////////////////////////////////////////////////////////////////////
  3881. // Execute the 'ORI' instruction 
  3882. ///////////////////////////////////////////////////////////////////////////////
  3883. int m68000::ExecuteORI(int opcode, String& trace_record, int trace)
  3884. {
  3885.   int status, size, in_register;
  3886.   unsigned long dest_addr, src_addr;
  3887.   unsigned int result, src, dest;
  3888.   String mnemonic;
  3889.  
  3890.   size=(opcode&0x00c0) >> 6;
  3891.  
  3892.   if(trace)
  3893.   {
  3894.     mnemonic+="{Mnemonic {ORI";
  3895.     if (size==BYTE)
  3896.       mnemonic+=".B ";
  3897.     else if (size==WORD)
  3898.       mnemonic+=".W ";
  3899.     else if (size==LONG)
  3900.       mnemonic+=".L ";
  3901.   }
  3902.  
  3903.   // Get the immediate data pointer
  3904.   if((status=ComputeEffectiveAddress(src_addr, in_register, mnemonic,
  3905.                     0x3c, size, trace)) != EXECUTE_OK)
  3906.   { return(status); }
  3907.  
  3908.   // Fetch the immediate data
  3909.   if((status=Peek(src_addr, src, size)) != EXECUTE_OK)
  3910.     return(status);
  3911.  
  3912.   if(trace)
  3913.     mnemonic+=",";
  3914.  
  3915.   // Get the destination data pointer
  3916.   if((status=ComputeEffectiveAddress(dest_addr, in_register, mnemonic,
  3917.                     opcode & 0x3f, size, trace)) != EXECUTE_OK)
  3918.   {
  3919.     return(status);
  3920.   }
  3921.  
  3922.   if(in_register)
  3923.   {
  3924.     dest=register_value[dest_addr];
  3925.     result=dest|src;
  3926.     SetConditionCodes(src,dest,result,size,
  3927.                       OTHER, C_FLAG|V_FLAG|Z_FLAG|N_FLAG);
  3928.     SetRegister(dest_addr,result,size);
  3929.   } 
  3930.   else
  3931.   {
  3932.     if((status=Peek(dest_addr, dest, size)) != EXECUTE_OK)
  3933.       return(status);
  3934.     result=dest|src;
  3935.     SetConditionCodes(src,dest,result,size, 
  3936.                       OTHER, C_FLAG|V_FLAG|Z_FLAG|N_FLAG);
  3937.     if((status=Poke(dest_addr, result, size)) != EXECUTE_OK)
  3938.       return(status);
  3939.   }
  3940.  
  3941.   if (trace)
  3942.   {
  3943.     mnemonic+="}} ";
  3944.     trace_record+=mnemonic;
  3945.   }
  3946.   return(EXECUTE_OK);
  3947. }
  3948.  
  3949. ///////////////////////////////////////////////////////////////////////////////
  3950. // Execute the 'ORItoCCR' instruction 
  3951. ///////////////////////////////////////////////////////////////////////////////
  3952. int m68000::ExecuteORItoCCR(int opcode, String& trace_record, int trace)
  3953. {
  3954.   int status, in_register_flag;
  3955.   unsigned long src_addr;
  3956.   unsigned int src;
  3957.   String mnemonic;
  3958.  
  3959.   if(trace)
  3960.     mnemonic+="{Mnemonic {ORI.B ";
  3961.  
  3962.   // Get the immediate data pointer
  3963.   if((status=ComputeEffectiveAddress(src_addr, in_register_flag, mnemonic,
  3964.                     0x3c, BYTE, trace)) != EXECUTE_OK)
  3965.   { return(status); }
  3966.  
  3967.   // Fetch the immediate data
  3968.   if((status=Peek(src_addr, src, BYTE)) != EXECUTE_OK)
  3969.     return(status);
  3970.  
  3971.   SetRegister(SR_INDEX, register_value[SR_INDEX]|src, BYTE);
  3972.   if (trace)
  3973.   {
  3974.     mnemonic+=",CCR}} ";
  3975.     trace_record+=mnemonic;
  3976.   }
  3977.   return(EXECUTE_OK);
  3978. }
  3979.  
  3980. ///////////////////////////////////////////////////////////////////////////////
  3981. // Execute the 'ORItoSR' instruction 
  3982. ///////////////////////////////////////////////////////////////////////////////
  3983. int m68000::ExecuteORItoSR(int opcode, String& trace_record, int trace)
  3984. {
  3985.   int status, in_register_flag;
  3986.   unsigned long src_addr;
  3987.   unsigned int src;
  3988.   String mnemonic;
  3989.  
  3990.   // Make sure we're in supervisor mode or trap
  3991.   if (!(register_value[SR_INDEX] & S_FLAG))
  3992.   {
  3993.     SetRegister(PC_INDEX, register_value[PC_INDEX]-2, LONG);
  3994.     if((status=ProcessException(8)) != EXECUTE_OK)
  3995.       return(status);
  3996.     if(trace);
  3997.       trace_record+="{Mnemonic {Privilege Violation Exception}} ";
  3998.     return(EXECUTE_PRIVILEGED_OK);
  3999.   }
  4000.  
  4001.   if(trace)
  4002.     mnemonic+="{Mnemonic {ORI.W ";
  4003.  
  4004.   // Get the immediate data pointer
  4005.   if((status=ComputeEffectiveAddress(src_addr, in_register_flag, mnemonic,
  4006.                     0x3c, WORD, trace)) != EXECUTE_OK)
  4007.   { return(status); }
  4008.  
  4009.   // Fetch the immediate data
  4010.   if((status=Peek(src_addr, src, WORD)) != EXECUTE_OK)
  4011.     return(status);
  4012.  
  4013.   SetRegister(SR_INDEX, register_value[SR_INDEX]|src, WORD);
  4014.  
  4015.   if (trace)
  4016.   {
  4017.     mnemonic+=",SR}} ";
  4018.     trace_record+=mnemonic;
  4019.   }
  4020.   return(EXECUTE_PRIVILEGED_OK);
  4021. }
  4022.  
  4023. ///////////////////////////////////////////////////////////////////////////////
  4024. // Execute the 'PEA' instruction 
  4025. ///////////////////////////////////////////////////////////////////////////////
  4026. int m68000::ExecutePEA(int opcode, String& trace_record, int trace)
  4027. {
  4028.   int status, in_register_flag, stack_index;
  4029.   unsigned long address;
  4030.   String ea_description;
  4031.  
  4032.   // Get the effective address
  4033.   if((status=ComputeEffectiveAddress(address, in_register_flag, ea_description,
  4034.                  opcode & 0x3f, LONG, trace)) != EXECUTE_OK)
  4035.   { return(status); }
  4036.  
  4037.   // Get the stack pointer index
  4038.   if(register_value[SR_INDEX]&S_FLAG)
  4039.     stack_index=SSP_INDEX;
  4040.   else
  4041.     stack_index=USP_INDEX;
  4042.  
  4043.   // Push the effective address onto the stack
  4044.   SetRegister(stack_index, register_value[stack_index]-4, LONG);
  4045.   if((status=Poke(register_value[stack_index], address, LONG)) != EXECUTE_OK)
  4046.     return(status);
  4047.  
  4048.   if(trace)
  4049.   {
  4050.     trace_record+="{Mnemonic {PEA.L ";
  4051.     trace_record+=ea_description;
  4052.     trace_record+="}} ";
  4053.   }
  4054.   return(EXECUTE_OK);
  4055. }
  4056.  
  4057. ///////////////////////////////////////////////////////////////////////////////
  4058. // Execute the 'RESET' instruction 
  4059. ///////////////////////////////////////////////////////////////////////////////
  4060. int m68000::ExecuteRESET(int opcode, String& trace_record, int trace)
  4061. {
  4062.   int status;
  4063.  
  4064.   // Make sure we're in supervisor mode or trap
  4065.   if (!(register_value[SR_INDEX] & S_FLAG))
  4066.   {
  4067.     SetRegister(PC_INDEX, register_value[PC_INDEX]-2, LONG);
  4068.     if((status=ProcessException(8)) != EXECUTE_OK)
  4069.       return(status);
  4070.     if(trace);
  4071.       trace_record+="{Mnemonic {Privilege Violation Exception}} ";
  4072.     return(EXECUTE_PRIVILEGED_OK);
  4073.   }
  4074.  
  4075.   // Tell the AddressSpace to reset all of the attached devices
  4076.   address_space->Reset();
  4077.  
  4078.   if(trace)
  4079.     trace_record+="{Mnemonic {RESET}} ";
  4080.     
  4081.   return(EXECUTE_PRIVILEGED_OK);
  4082. }
  4083.  
  4084. ///////////////////////////////////////////////////////////////////////////////
  4085. // Execute the 'ROL' instruction 
  4086. ///////////////////////////////////////////////////////////////////////////////
  4087. int m68000::ExecuteROL(int opcode, String& trace_record, int trace)
  4088. {
  4089.   int status, size, in_register_flag, shift_count;
  4090.   unsigned long address;
  4091.   unsigned int data;
  4092.   String ea_description;
  4093.  
  4094.   size=(opcode&0x00c0) >> 6;
  4095.  
  4096.   // Check to see if this is a memory or register rotate
  4097.   if(size == 3)
  4098.   {
  4099.     size=WORD;    // Memory always rotates a word
  4100.  
  4101.     // Get the address
  4102.     if((status=ComputeEffectiveAddress(address,in_register_flag,ea_description,
  4103.                  opcode & 0x3f, size, trace)) != EXECUTE_OK)
  4104.     { return(status); }
  4105.  
  4106.     // Fetch the data
  4107.     if((status=Peek(address, data, size)) != EXECUTE_OK)
  4108.       return(status);
  4109.  
  4110.     // Rotate the data to the left by one bit.
  4111.     if(data&0x8000)
  4112.       data=(data << 1) | 0x0001;
  4113.     else
  4114.       data=(data << 1);
  4115.  
  4116.     // Store the shifted data
  4117.     if((status=Poke(address, data, size)) != EXECUTE_OK)
  4118.       return(status);
  4119.  
  4120.     SetConditionCodes(0, 0, data, size, OTHER, N_FLAG|Z_FLAG|C_FLAG|V_FLAG); 
  4121.     if(data&0x0001)
  4122.       register_value[SR_INDEX] |= C_FLAG;
  4123.   }
  4124.   else
  4125.   {
  4126.     // Compute the shift count
  4127.     if(opcode&32)
  4128.     {
  4129.       shift_count=register_value[D0_INDEX+((opcode&0x0e00) >> 9)] & 0x3f;
  4130.       if(trace)
  4131.         ea_description=register_data[D0_INDEX+((opcode&0x0e00) >> 9)].name;
  4132.     }
  4133.     else
  4134.     {
  4135.       if((shift_count=(opcode&0x0e00) >> 9) == 0)
  4136.         shift_count=8;
  4137.  
  4138.       if(trace)
  4139.       {
  4140.         ea_description="#$";
  4141.         ea_description+=IntToString(shift_count,1);
  4142.       }
  4143.     }
  4144.  
  4145.     if(trace)
  4146.     {
  4147.       ea_description+=",";
  4148.       ea_description+=register_data[D0_INDEX+(opcode&7)].name;
  4149.     }
  4150.  
  4151.     unsigned int msb;
  4152.  
  4153.     // Setup MSB  
  4154.     if(size==BYTE)
  4155.       msb=0x80;
  4156.     else if(size==WORD)
  4157.       msb=0x8000;
  4158.     else
  4159.       msb=0x80000000;
  4160.  
  4161.     // Perform the shift on the data
  4162.     data=register_value[D0_INDEX+(opcode&7)];
  4163.     for(int t=0;t<shift_count;++t)
  4164.     {
  4165.       if(data&msb)
  4166.         data=(data << 1) | 1;
  4167.       else
  4168.         data=(data << 1);
  4169.     }
  4170.  
  4171.     SetRegister(D0_INDEX+(opcode&7), data, size);
  4172.  
  4173.     SetConditionCodes(0, 0, data, size, OTHER, N_FLAG|Z_FLAG|C_FLAG|V_FLAG); 
  4174.     if(data&1)
  4175.       register_value[SR_INDEX] |= C_FLAG;
  4176.   }
  4177.  
  4178.   if (trace)
  4179.   {
  4180.     trace_record+="{Mnemonic {ROL";
  4181.     if(size==BYTE)
  4182.       trace_record+=".B ";
  4183.     else if(size==WORD)
  4184.       trace_record+=".W ";
  4185.     else if(size==LONG)
  4186.       trace_record+=".L ";
  4187.     trace_record+=ea_description;
  4188.     trace_record+="}} ";
  4189.   }
  4190.   return(EXECUTE_OK);
  4191. }
  4192.  
  4193. ///////////////////////////////////////////////////////////////////////////////
  4194. // Execute the 'ROR' instruction 
  4195. ///////////////////////////////////////////////////////////////////////////////
  4196. int m68000::ExecuteROR(int opcode, String& trace_record, int trace)
  4197. {
  4198.   int status, size, in_register_flag, shift_count;
  4199.   unsigned long address;
  4200.   unsigned int data;
  4201.   String ea_description;
  4202.  
  4203.   size=(opcode&0x00c0) >> 6;
  4204.  
  4205.   // Check to see if this is a memory or register rotate
  4206.   if(size == 3)
  4207.   {
  4208.     size=WORD;    // Memory always rotates a word
  4209.  
  4210.     // Get the address
  4211.     if((status=ComputeEffectiveAddress(address,in_register_flag,ea_description,
  4212.                  opcode & 0x3f, size, trace)) != EXECUTE_OK)
  4213.     { return(status); }
  4214.  
  4215.     // Fetch the data
  4216.     if((status=Peek(address, data, size)) != EXECUTE_OK)
  4217.       return(status);
  4218.  
  4219.     // Rotate the data to the right by one bit.
  4220.     if(data&1)
  4221.       data=0x8000 | (data >> 1);
  4222.     else
  4223.       data=(data >> 1) & 0x7fff;
  4224.  
  4225.     // Store the shifted data
  4226.     if((status=Poke(address, data, size)) != EXECUTE_OK)
  4227.       return(status);
  4228.  
  4229.     // Set the condition codes
  4230.     SetConditionCodes(0, 0, data, size, OTHER, N_FLAG|Z_FLAG|C_FLAG|V_FLAG); 
  4231.     if(data & 0x8000)
  4232.       register_value[SR_INDEX] |= C_FLAG;
  4233.   }
  4234.   else
  4235.   {
  4236.     // Compute the shift count
  4237.     if(opcode&32)
  4238.     {
  4239.       shift_count=register_value[D0_INDEX+((opcode&0x0e00) >> 9)] & 0x3f;
  4240.       if(trace)
  4241.         ea_description=register_data[D0_INDEX+((opcode&0x0e00) >> 9)].name;
  4242.     }
  4243.     else
  4244.     {
  4245.       if((shift_count=(opcode&0x0e00) >> 9) == 0)
  4246.         shift_count=8;
  4247.  
  4248.       if(trace)
  4249.       {
  4250.         ea_description="#$";
  4251.         ea_description+=IntToString(shift_count,1);
  4252.       }
  4253.     }
  4254.  
  4255.     if(trace)
  4256.     {
  4257.       ea_description+=",";
  4258.       ea_description+=register_data[D0_INDEX+(opcode&7)].name;
  4259.     }
  4260.  
  4261.     unsigned int msb;
  4262.  
  4263.     // Setup most sign. byte indicator
  4264.     if(size==BYTE)
  4265.       msb=0x80;
  4266.     else if(size==WORD)
  4267.       msb=0x8000;
  4268.     else
  4269.       msb=0x80000000;
  4270.  
  4271.     // Perform the shift on the data
  4272.     data=register_value[D0_INDEX+(opcode&7)];
  4273.     for(int t=0;t<shift_count;++t)
  4274.     {
  4275.       if(data&1)
  4276.         data=msb | (data >> 1);
  4277.       else
  4278.         data=(data >> 1) & ~msb;
  4279.     }
  4280.     
  4281.     SetRegister(D0_INDEX+(opcode&7), data, size);
  4282.  
  4283.     SetConditionCodes(0, 0, data, size, OTHER, N_FLAG|Z_FLAG|C_FLAG|V_FLAG); 
  4284.     if(data&msb)
  4285.       register_value[SR_INDEX] |= C_FLAG;
  4286.   }
  4287.  
  4288.   if (trace)
  4289.   {
  4290.     trace_record+="{Mnemonic {ROR";
  4291.     if(size==BYTE)
  4292.       trace_record+=".B ";
  4293.     else if(size==WORD)
  4294.       trace_record+=".W ";
  4295.     else if(size==LONG)
  4296.       trace_record+=".L ";
  4297.     trace_record+=ea_description;
  4298.     trace_record+="}} ";
  4299.   }
  4300.   return(EXECUTE_OK);
  4301. }
  4302.  
  4303. ///////////////////////////////////////////////////////////////////////////////
  4304. // Execute the 'ROXL' instruction 
  4305. ///////////////////////////////////////////////////////////////////////////////
  4306. int m68000::ExecuteROXL(int opcode, String& trace_record, int trace)
  4307. {
  4308.   int status, size, in_register_flag, shift_count;
  4309.   unsigned long address;
  4310.   unsigned int data;
  4311.   String ea_description;
  4312.  
  4313.   size=(opcode&0x00c0) >> 6;
  4314.  
  4315.   // Check to see if this is a memory or register rotate
  4316.   if(size == 3)
  4317.   {
  4318.     size=WORD;    // Memory always rotates a word
  4319.  
  4320.     // Get the address
  4321.     if((status=ComputeEffectiveAddress(address,in_register_flag,ea_description,
  4322.                  opcode & 0x3f, size, trace)) != EXECUTE_OK)
  4323.     { return(status); }
  4324.  
  4325.     // Fetch the data
  4326.     if((status=Peek(address, data, size)) != EXECUTE_OK)
  4327.       return(status);
  4328.  
  4329.     // Rotate the data to the left by one bit.
  4330.     if(register_value[SR_INDEX]&X_FLAG)
  4331.       data=(data << 1) | 0x0001;
  4332.     else
  4333.       data=(data << 1);
  4334.  
  4335.     // Store the shifted data
  4336.     if((status=Poke(address, data, size)) != EXECUTE_OK)
  4337.       return(status);
  4338.  
  4339.     SetConditionCodes(0,0,data,size,OTHER,N_FLAG|Z_FLAG|C_FLAG|X_FLAG|V_FLAG); 
  4340.     if(data&0x00010000)
  4341.     {
  4342.       register_value[SR_INDEX] |= C_FLAG;
  4343.       register_value[SR_INDEX] |= X_FLAG;
  4344.     }
  4345.   }
  4346.   else
  4347.   {
  4348.     // Compute the shift count
  4349.     if(opcode&32)
  4350.     {
  4351.       shift_count=register_value[D0_INDEX+((opcode&0x0e00) >> 9)] & 0x3f;
  4352.       if(trace)
  4353.         ea_description=register_data[D0_INDEX+((opcode&0x0e00) >> 9)].name;
  4354.     }
  4355.     else
  4356.     {
  4357.       if((shift_count=(opcode&0x0e00) >> 9) == 0)
  4358.         shift_count=8;
  4359.  
  4360.       if(trace)
  4361.       {
  4362.         ea_description="#$";
  4363.         ea_description+=IntToString(shift_count,1);
  4364.       }
  4365.     }
  4366.  
  4367.     if(trace)
  4368.     {
  4369.       ea_description+=",";
  4370.       ea_description+=register_data[D0_INDEX+(opcode&7)].name;
  4371.     }
  4372.  
  4373.     unsigned int msb, extend;
  4374.  
  4375.     // Setup msb
  4376.     if(size==BYTE)
  4377.       msb=0x80;
  4378.     else if(size==WORD)
  4379.       msb=0x8000;
  4380.     else
  4381.       msb=0x80000000;
  4382.  
  4383.     // Set extend
  4384.     extend=register_value[SR_INDEX]&X_FLAG;
  4385.  
  4386.     // Perform the shift on the data
  4387.     data=register_value[D0_INDEX+(opcode&7)];
  4388.     for(int t=0;t<shift_count;++t)
  4389.     {
  4390.       if(extend)
  4391.       {
  4392.         extend=data&msb;
  4393.         data=(data << 1) | 1;
  4394.       }
  4395.       else
  4396.       {
  4397.         extend=data&msb;
  4398.         data=(data << 1);
  4399.       }
  4400.     }
  4401.  
  4402.     SetRegister(D0_INDEX+(opcode&7), data, size);
  4403.  
  4404.     SetConditionCodes(0,0,data,size,OTHER,N_FLAG|Z_FLAG|X_FLAG|C_FLAG|V_FLAG); 
  4405.     if(extend)
  4406.     {
  4407.       register_value[SR_INDEX] |= C_FLAG;
  4408.       register_value[SR_INDEX] |= X_FLAG;
  4409.     }
  4410.   }
  4411.  
  4412.   if (trace)
  4413.   {
  4414.     trace_record+="{Mnemonic {ROXL";
  4415.     if(size==BYTE)
  4416.       trace_record+=".B ";
  4417.     else if(size==WORD)
  4418.       trace_record+=".W ";
  4419.     else if(size==LONG)
  4420.       trace_record+=".L ";
  4421.     trace_record+=ea_description;
  4422.     trace_record+="}} ";
  4423.   }
  4424.   return(EXECUTE_OK);
  4425. }
  4426.  
  4427. ///////////////////////////////////////////////////////////////////////////////
  4428. // Execute the 'ROXR' instruction 
  4429. ///////////////////////////////////////////////////////////////////////////////
  4430. int m68000::ExecuteROXR(int opcode, String& trace_record, int trace)
  4431. {
  4432.   int status, size, in_register_flag, shift_count;
  4433.   unsigned long address;
  4434.   unsigned int data;
  4435.   String ea_description;
  4436.  
  4437.   size=(opcode&0x00c0) >> 6;
  4438.  
  4439.   // Check to see if this is a memory or register rotate
  4440.   if(size == 3)
  4441.   {
  4442.     size=WORD;    // Memory always rotates a word
  4443.  
  4444.     // Get the address
  4445.     if((status=ComputeEffectiveAddress(address,in_register_flag,ea_description,
  4446.                  opcode & 0x3f, size, trace)) != EXECUTE_OK)
  4447.     { return(status); }
  4448.  
  4449.     // Fetch the data
  4450.     if((status=Peek(address, data, size)) != EXECUTE_OK)
  4451.       return(status);
  4452.  
  4453.     // Set carry flag
  4454.     int carry=data&1;
  4455.  
  4456.     // Rotate the data to the right by one bit.
  4457.     if(register_value[SR_INDEX]&X_FLAG)
  4458.       data=0x8000 | (data >> 1);
  4459.     else
  4460.       data=(data >> 1) & 0x7fff;
  4461.  
  4462.     // Store the shifted data
  4463.     if((status=Poke(address, data, size)) != EXECUTE_OK)
  4464.       return(status);
  4465.  
  4466.     // Set the condition codes
  4467.     SetConditionCodes(0,0,data,size,OTHER,N_FLAG|Z_FLAG|X_FLAG|C_FLAG|V_FLAG); 
  4468.     if(carry)
  4469.     {
  4470.       register_value[SR_INDEX] |= C_FLAG;
  4471.       register_value[SR_INDEX] |= X_FLAG;
  4472.     }
  4473.   }
  4474.   else
  4475.   {
  4476.     // Compute the shift count
  4477.     if(opcode&32)
  4478.     {
  4479.       shift_count=register_value[D0_INDEX+((opcode&0x0e00) >> 9)] & 0x3f;
  4480.       if(trace)
  4481.         ea_description=register_data[D0_INDEX+((opcode&0x0e00) >> 9)].name;
  4482.     }
  4483.     else
  4484.     {
  4485.       if((shift_count=(opcode&0x0e00) >> 9) == 0)
  4486.         shift_count=8;
  4487.  
  4488.       if(trace)
  4489.       {
  4490.         ea_description="#$";
  4491.         ea_description+=IntToString(shift_count,1);
  4492.       }
  4493.     }
  4494.  
  4495.     if(trace)
  4496.     {
  4497.       ea_description+=",";
  4498.       ea_description+=register_data[D0_INDEX+(opcode&7)].name;
  4499.     }
  4500.  
  4501.     unsigned int msb,extend;
  4502.  
  4503.     // Setup most sign. byte indicator
  4504.     if(size==BYTE)
  4505.       msb=0x80;
  4506.     else if(size==WORD)
  4507.       msb=0x8000;
  4508.     else
  4509.       msb=0x80000000;
  4510.  
  4511.     extend=register_value[SR_INDEX]&X_FLAG;
  4512.  
  4513.     // Perform the shift on the data
  4514.     data=register_value[D0_INDEX+(opcode&7)];
  4515.     for(int t=0;t<shift_count;++t)
  4516.     {
  4517.       if(extend)
  4518.       {
  4519.         extend=data&1;
  4520.         data=msb | (data >> 1);
  4521.       }
  4522.       else
  4523.       {
  4524.         extend=data&1;
  4525.         data=(data >> 1) & ~msb;
  4526.       }
  4527.     }
  4528.     
  4529.     SetRegister(D0_INDEX+(opcode&7), data, size);
  4530.  
  4531.     SetConditionCodes(0,0,data,size,OTHER,N_FLAG|Z_FLAG|X_FLAG|C_FLAG|V_FLAG); 
  4532.     if(extend)
  4533.     {
  4534.       register_value[SR_INDEX] |= C_FLAG;
  4535.       register_value[SR_INDEX] |= X_FLAG;
  4536.     }
  4537.   }
  4538.  
  4539.   if (trace)
  4540.   {
  4541.     trace_record+="{Mnemonic {ROXR";
  4542.     if(size==BYTE)
  4543.       trace_record+=".B ";
  4544.     else if(size==WORD)
  4545.       trace_record+=".W ";
  4546.     else if(size==LONG)
  4547.       trace_record+=".L ";
  4548.     trace_record+=ea_description;
  4549.     trace_record+="}} ";
  4550.   }
  4551.   return(EXECUTE_OK);
  4552. }
  4553.  
  4554. ///////////////////////////////////////////////////////////////////////////////
  4555. // Execute the 'RTE' instruction 
  4556. ///////////////////////////////////////////////////////////////////////////////
  4557. int m68000::ExecuteRTE(int opcode, String& trace_record, int trace)
  4558. {
  4559.   int status;
  4560.   unsigned int sr,pc;
  4561.  
  4562.   // Make sure we're in supervisor mode or trap
  4563.   if(!(register_value[SR_INDEX] & S_FLAG))
  4564.   {
  4565.     SetRegister(PC_INDEX, register_value[PC_INDEX]-2, LONG);
  4566.     if((status=ProcessException(8)) != EXECUTE_OK)
  4567.       return(status);
  4568.     if(trace);
  4569.       trace_record+="{Mnemonic {Privilege Violation Exception}} ";
  4570.     return(EXECUTE_PRIVILEGED_OK);
  4571.   }
  4572.  
  4573.   // Pop the SR off the stack
  4574.   if((status=Peek(register_value[SSP_INDEX], sr, WORD)) != EXECUTE_OK)
  4575.     return(status);
  4576.  
  4577.   SetRegister(SSP_INDEX, register_value[SSP_INDEX]+2, LONG);
  4578.   SetRegister(SR_INDEX, sr, WORD);
  4579.  
  4580.   // Pop the PC off the stack
  4581.   if((status=Peek(register_value[SSP_INDEX], pc, LONG)) != EXECUTE_OK)
  4582.     return(status);
  4583.  
  4584.   SetRegister(SSP_INDEX, register_value[SSP_INDEX]+4, LONG);
  4585.   SetRegister(PC_INDEX, pc, LONG);
  4586.  
  4587.   if(trace)
  4588.     trace_record+="{Mnemonic {RTE}} ";
  4589.  
  4590.   return(EXECUTE_PRIVILEGED_OK);
  4591. }
  4592.  
  4593. ///////////////////////////////////////////////////////////////////////////////
  4594. // Execute the 'RTR' instruction 
  4595. ///////////////////////////////////////////////////////////////////////////////
  4596. int m68000::ExecuteRTR(int opcode, String& trace_record, int trace)
  4597. {
  4598.   int status;
  4599.   unsigned int ccr,pc;
  4600.   int stackRegister;
  4601.  
  4602.   // Determine which stack pointer to use
  4603.   if(register_value[SR_INDEX] & S_FLAG)
  4604.     stackRegister = SSP_INDEX;
  4605.   else
  4606.     stackRegister = USP_INDEX;
  4607.  
  4608.   // Pop the CCR off the stack
  4609.   if((status = Peek(register_value[stackRegister], ccr, WORD)) != EXECUTE_OK)
  4610.     return(status);
  4611.  
  4612.   SetRegister(stackRegister, register_value[stackRegister] + 2, LONG);
  4613.   SetRegister(SR_INDEX, ccr, BYTE);
  4614.  
  4615.   // Pop the PC off the stack
  4616.   if((status = Peek(register_value[stackRegister], pc, LONG)) != EXECUTE_OK)
  4617.     return(status);
  4618.  
  4619.   SetRegister(stackRegister, register_value[stackRegister] + 4, LONG);
  4620.   SetRegister(PC_INDEX, pc, LONG);
  4621.  
  4622.   if(trace)
  4623.     trace_record += "{Mnemonic {RTR}} ";
  4624.  
  4625.   return(EXECUTE_OK);
  4626. }
  4627.  
  4628. ///////////////////////////////////////////////////////////////////////////////
  4629. // Execute the 'RTS' instruction 
  4630. ///////////////////////////////////////////////////////////////////////////////
  4631. int m68000::ExecuteRTS(int opcode, String& trace_record, int trace)
  4632. {
  4633.   int status;
  4634.   unsigned int pc;
  4635.   int stackRegister;
  4636.  
  4637.   // Determine which stack pointer to use
  4638.   if(register_value[SR_INDEX] & S_FLAG)
  4639.     stackRegister = SSP_INDEX;
  4640.   else
  4641.     stackRegister = USP_INDEX;
  4642.  
  4643.   // Pop the PC off the stack
  4644.   if((status = Peek(register_value[stackRegister], pc, LONG)) != EXECUTE_OK)
  4645.     return(status);
  4646.  
  4647.   SetRegister(stackRegister, register_value[stackRegister] + 4, LONG);
  4648.   SetRegister(PC_INDEX, pc, LONG);
  4649.  
  4650.   if(trace)
  4651.     trace_record += "{Mnemonic {RTS}} ";
  4652.  
  4653.   return(EXECUTE_OK);
  4654. }
  4655.  
  4656. ///////////////////////////////////////////////////////////////////////////////
  4657. // Execute the '' instruction 
  4658. ///////////////////////////////////////////////////////////////////////////////
  4659. int m68000::ExecuteSBCD(int opcode, String& trace_record, int trace)
  4660. { 
  4661.   return(ExecuteInvalid(opcode, trace_record, trace));
  4662. }
  4663.  
  4664. ///////////////////////////////////////////////////////////////////////////////
  4665. // Execute the 'STOP' instruction 
  4666. ///////////////////////////////////////////////////////////////////////////////
  4667. int m68000::ExecuteSTOP(int opcode, String& trace_record, int trace)
  4668. {
  4669.   unsigned int newStatusRegister, status;
  4670.   String mnemonic;
  4671.  
  4672.   // Fetch the 16-bit immediate data
  4673.   status = Peek(register_value[PC_INDEX], newStatusRegister, WORD);
  4674.   if(status != EXECUTE_OK)
  4675.     return(status);
  4676.  
  4677.   // Increment the program counter
  4678.   SetRegister(PC_INDEX, register_value[PC_INDEX]+2, LONG);
  4679.  
  4680.   // Set the status register
  4681.   SetRegister(SR_INDEX, newStatusRegister, WORD);
  4682.  
  4683.   // Make sure the S-Bit is set
  4684.   if(!(register_value[SR_INDEX] & S_FLAG))
  4685.   {
  4686.     if((status=ProcessException(8)) != EXECUTE_OK)
  4687.       return(status);
  4688.     if(trace)
  4689.       trace_record+="{Mnemonic {Privilege Violation Exception}} ";
  4690.     return(EXECUTE_PRIVILEGED_OK);
  4691.   }
  4692.   
  4693.   // Stop the processor
  4694.   processor_state = STOP_STATE;
  4695.  
  4696.   if(trace)
  4697.   {
  4698.     trace_record += "{Mnemonic {STOP #$";
  4699.     trace_record += IntToString(newStatusRegister, 4);
  4700.     trace_record += "}} ";
  4701.   } 
  4702.   return(EXECUTE_PRIVILEGED_OK);
  4703. }
  4704.  
  4705. ///////////////////////////////////////////////////////////////////////////////
  4706. // Execute the 'BREAK' instruction 
  4707. ///////////////////////////////////////////////////////////////////////////////
  4708. int m68000::ExecuteBREAK(int opcode, String& trace_record, int trace)
  4709. {
  4710.  
  4711.   // Put the processor in our "fake" break state so the simulator will
  4712.   // stop running a program.
  4713.   processor_state = BREAK_STATE;
  4714.  
  4715.   if(trace)
  4716.     trace_record+="{Mnemonic {BREAK}} ";
  4717.  
  4718.   return(EXECUTE_OK);
  4719. }
  4720.  
  4721. ///////////////////////////////////////////////////////////////////////////////
  4722. // Execute the 'SUB' instruction 
  4723. ///////////////////////////////////////////////////////////////////////////////
  4724. int m68000::ExecuteSUB(int opcode, String& trace_record, int trace)
  4725. {
  4726.   int status, size, in_register_flag;
  4727.   unsigned long ea_address, register_number;
  4728.   unsigned int result, ea_data;
  4729.   String mnemonic, ea_description;
  4730.  
  4731.   size=(opcode&0x00c0) >> 6;
  4732.  
  4733.   // Get the <ea> data address
  4734.   if((status=ComputeEffectiveAddress(ea_address, in_register_flag,
  4735.                   ea_description, opcode & 0x3f, size, trace)) != EXECUTE_OK)
  4736.   { return(status); }
  4737.  
  4738.   // Fetch the <ea> data 
  4739.   if(in_register_flag)
  4740.     ea_data=register_value[ea_address];
  4741.   else
  4742.     if((status=Peek(ea_address, ea_data, size)) != EXECUTE_OK)
  4743.       return(status);
  4744.  
  4745.   // Get the register number
  4746.   register_number=D0_INDEX+((opcode&0x0e00) >> 9);
  4747.  
  4748.   if(trace)
  4749.   {
  4750.     mnemonic+="{Mnemonic {SUB";
  4751.     if (size==BYTE)
  4752.       mnemonic+=".B ";
  4753.     else if (size==WORD)
  4754.       mnemonic+=".W ";
  4755.     else if (size==LONG)
  4756.       mnemonic+=".L ";
  4757.   }
  4758.  
  4759.   if(opcode & 0x0100)    // <ea> - <Dn> -> <ea>
  4760.   {
  4761.     if(trace)
  4762.     {
  4763.       mnemonic+=register_data[register_number].name;
  4764.       mnemonic+=",";
  4765.       mnemonic+=ea_description;
  4766.     }
  4767.     result=ea_data-register_value[register_number];
  4768.     SetConditionCodes(register_value[register_number], ea_data, result, size,
  4769.                       SUBTRACTION, C_FLAG|V_FLAG|Z_FLAG|N_FLAG|X_FLAG);
  4770.     if((status=Poke(ea_address, result, size)) != EXECUTE_OK)
  4771.       return(status);
  4772.   }
  4773.   else                   // <Dn> - <ea> -> <Dn>
  4774.   {
  4775.     if(trace)
  4776.     {
  4777.       mnemonic+=ea_description;
  4778.       mnemonic+=",";
  4779.       mnemonic+=register_data[register_number].name;
  4780.     }
  4781.     result=register_value[register_number]-ea_data;
  4782.     SetConditionCodes(ea_data, register_value[register_number], result, size,
  4783.                       SUBTRACTION, C_FLAG|V_FLAG|Z_FLAG|N_FLAG|X_FLAG);
  4784.     SetRegister(register_number, result, size);
  4785.   }
  4786.  
  4787.   if(trace)
  4788.   {
  4789.     mnemonic+="}} ";
  4790.     trace_record+=mnemonic;
  4791.   }
  4792.   return(EXECUTE_OK);
  4793. }
  4794.  
  4795. ///////////////////////////////////////////////////////////////////////////////
  4796. // Execute the 'SUBA' instruction 
  4797. ///////////////////////////////////////////////////////////////////////////////
  4798. int m68000::ExecuteSUBA(int opcode, String& trace_record, int trace)
  4799. {
  4800.   int status, size, in_register_flag;
  4801.   unsigned long ea_address, register_number;
  4802.   unsigned int result, ea_data;
  4803.   String ea_description;
  4804.  
  4805.   if (opcode&0x0100)
  4806.     size=LONG;
  4807.   else
  4808.     size=WORD;
  4809.  
  4810.   // Get the <ea> data address
  4811.   if((status=ComputeEffectiveAddress(ea_address, in_register_flag,
  4812.                   ea_description, opcode & 0x3f, size, trace)) != EXECUTE_OK)
  4813.   { return(status); }
  4814.  
  4815.   // Fetch the <ea> data 
  4816.   if(in_register_flag)
  4817.     ea_data=register_value[ea_address];
  4818.   else
  4819.     if((status=Peek(ea_address, ea_data, size)) != EXECUTE_OK)
  4820.       return(status);
  4821.  
  4822.   ea_data=SignExtend(ea_data,size);
  4823.  
  4824.   // Get the register number
  4825.   register_number=A0_INDEX+((opcode&0x0e00) >> 9);
  4826.  
  4827.   // Adjust register_number if it's A7 and we're in supervisor mode
  4828.   if((register_number == USP_INDEX) && (register_value[SR_INDEX] & S_FLAG))
  4829.     register_number = SSP_INDEX;
  4830.  
  4831.   result=register_value[register_number]-ea_data;
  4832.   SetRegister(register_number, result, LONG);
  4833.  
  4834.   if(trace)
  4835.   {
  4836.     trace_record+="{Mnemonic {SUBA";
  4837.     if (size==WORD)
  4838.       trace_record+=".W ";
  4839.     else if (size==LONG)
  4840.       trace_record+=".L ";
  4841.     trace_record+=ea_description;
  4842.     trace_record+=",";
  4843.     trace_record+=register_data[register_number].name;
  4844.     trace_record+="}} ";
  4845.   }
  4846.   return(EXECUTE_OK);
  4847. }
  4848.  
  4849. ///////////////////////////////////////////////////////////////////////////////
  4850. // Execute the 'SUBI' instruction 
  4851. ///////////////////////////////////////////////////////////////////////////////
  4852. int m68000::ExecuteSUBI(int opcode, String& trace_record, int trace)
  4853. {
  4854.   int status, size, in_register;
  4855.   unsigned long dest_addr, src_addr;
  4856.   unsigned int result, src, dest;
  4857.   String mnemonic;
  4858.  
  4859.   size=(opcode&0x00c0) >> 6;
  4860.  
  4861.   if(trace)
  4862.   {
  4863.     mnemonic+="{Mnemonic {SUBI";
  4864.     if (size==BYTE)
  4865.       mnemonic+=".B ";
  4866.     else if (size==WORD)
  4867.       mnemonic+=".W ";
  4868.     else if (size==LONG)
  4869.       mnemonic+=".L ";
  4870.   }
  4871.  
  4872.   // Get the immediate data pointer
  4873.   if((status=ComputeEffectiveAddress(src_addr, in_register, mnemonic,
  4874.                     0x3c, size, trace)) != EXECUTE_OK)
  4875.   { return(status); }
  4876.  
  4877.   // Fetch the immediate data
  4878.   if((status=Peek(src_addr, src, size)) != EXECUTE_OK)
  4879.     return(status);
  4880.  
  4881.   if(trace)
  4882.     mnemonic+=",";
  4883.  
  4884.   // Get the destination data pointer
  4885.   if((status=ComputeEffectiveAddress(dest_addr, in_register, mnemonic,
  4886.                     opcode & 0x3f, size, trace)) != EXECUTE_OK)
  4887.   {
  4888.     return(status);
  4889.   }
  4890.  
  4891.   if(in_register)
  4892.   {
  4893.     dest=register_value[dest_addr];
  4894.     result=dest-src;
  4895.     SetConditionCodes(src,dest,result,size,
  4896.                       SUBTRACTION, C_FLAG|V_FLAG|Z_FLAG|N_FLAG|X_FLAG);
  4897.     SetRegister(dest_addr,result,size);
  4898.   } 
  4899.   else
  4900.   {
  4901.     if((status=Peek(dest_addr, dest, size)) != EXECUTE_OK)
  4902.       return(status);
  4903.     result=dest-src;
  4904.     SetConditionCodes(src,dest,result,size,
  4905.                       SUBTRACTION, C_FLAG|V_FLAG|Z_FLAG|N_FLAG|X_FLAG);
  4906.     if((status=Poke(dest_addr, result, size)) != EXECUTE_OK)
  4907.       return(status);
  4908.   }
  4909.  
  4910.   if (trace)
  4911.   {
  4912.     mnemonic+="}} ";
  4913.     trace_record+=mnemonic;
  4914.   }
  4915.   return(EXECUTE_OK);
  4916. }
  4917.  
  4918. ///////////////////////////////////////////////////////////////////////////////
  4919. // Execute the 'SUBQ' instruction 
  4920. ///////////////////////////////////////////////////////////////////////////////
  4921. int m68000::ExecuteSUBQ(int opcode, String& trace_record, int trace)
  4922. {
  4923.   int status, size, in_register_flag;
  4924.   unsigned long ea_address, immediate_data;
  4925.   unsigned int result, ea_data;
  4926.   String ea_description;
  4927.  
  4928.   size=(opcode&0x00c0) >> 6;
  4929.  
  4930.   // Get the immediate data out of the opcode
  4931.   if((immediate_data=(opcode&0x0e00) >> 9) == 0)
  4932.     immediate_data=8;
  4933.  
  4934.   // Get the <ea> data address
  4935.   if((status=ComputeEffectiveAddress(ea_address, in_register_flag,
  4936.                   ea_description, opcode & 0x3f, size, trace)) != EXECUTE_OK)
  4937.   { return(status); }
  4938.  
  4939.   // Fetch the <ea> data 
  4940.   if(in_register_flag)
  4941.     ea_data=register_value[ea_address];
  4942.   else
  4943.     if((status=Peek(ea_address, ea_data, size)) != EXECUTE_OK)
  4944.       return(status);
  4945.  
  4946.   if(in_register_flag)
  4947.   {
  4948.     result=ea_data-immediate_data;
  4949.     if((ea_address>=A0_INDEX) && (ea_address<=SSP_INDEX))
  4950.     {
  4951.       SetRegister(ea_address, result, LONG);
  4952.     }
  4953.     else
  4954.     {
  4955.       SetConditionCodes(immediate_data, ea_data, result, size,
  4956.                         SUBTRACTION, C_FLAG|V_FLAG|Z_FLAG|N_FLAG|X_FLAG);
  4957.       SetRegister(ea_address, result, size);
  4958.     }
  4959.   }
  4960.   else
  4961.   {
  4962.     result=ea_data-immediate_data;
  4963.     SetConditionCodes(immediate_data, ea_data, result, size,
  4964.                       SUBTRACTION, C_FLAG|V_FLAG|Z_FLAG|N_FLAG|X_FLAG);
  4965.     if((status=Poke(ea_address, result, size)) != EXECUTE_OK)
  4966.       return(status);
  4967.   }
  4968.  
  4969.   if(trace)
  4970.   {
  4971.     trace_record+="{Mnemonic {SUBQ";
  4972.     if (size==BYTE)
  4973.       trace_record+=".B ";
  4974.     else if (size==WORD)
  4975.       trace_record+=".W ";
  4976.     else if (size==LONG)
  4977.       trace_record+=".L ";
  4978.     trace_record+="#$";
  4979.     trace_record+=IntToString(immediate_data,1);
  4980.     trace_record+=",";
  4981.     trace_record+=ea_description;
  4982.     trace_record+="}} ";
  4983.   }
  4984.   return(EXECUTE_OK);
  4985. }
  4986.  
  4987. ///////////////////////////////////////////////////////////////////////////////
  4988. // Execute the 'SUBX' instruction 
  4989. ///////////////////////////////////////////////////////////////////////////////
  4990. int m68000::ExecuteSUBX(int opcode, String& trace_record, int trace)
  4991. {
  4992.   int status, size, in_register_flag;
  4993.   unsigned long src_address, dest_address;
  4994.   unsigned int result, src, dest;
  4995.   String mnemonic;
  4996.  
  4997.   size = (opcode & 0x00c0) >> 6;
  4998.  
  4999.   if(trace)
  5000.   {
  5001.     mnemonic += "{Mnemonic {SUBX";
  5002.     if(size == BYTE)
  5003.       mnemonic += ".B ";
  5004.     else if(size == WORD)
  5005.       mnemonic += ".W ";
  5006.     else if(size == LONG)
  5007.       mnemonic += ".L ";
  5008.   }
  5009.  
  5010.   // Get the addresses
  5011.   if(opcode & 8)
  5012.   {
  5013.     if((status = ComputeEffectiveAddress(src_address, in_register_flag,
  5014.             mnemonic, 0x20 | (opcode & 7) , size, trace)) != EXECUTE_OK)
  5015.     { return(status); }
  5016.  
  5017.     if(trace)
  5018.       mnemonic += ",";
  5019.  
  5020.     if((status = ComputeEffectiveAddress(dest_address, in_register_flag,
  5021.             mnemonic, 0x20 | ((opcode & 0x0e00) >> 9), size, trace)) != EXECUTE_OK)
  5022.     { return(status); }
  5023.  
  5024.     if((status = Peek(src_address, src, size)) != EXECUTE_OK)
  5025.       return(status);
  5026.     if((status = Peek(dest_address, dest, size)) != EXECUTE_OK)
  5027.       return(status);
  5028.   }
  5029.   else
  5030.   {
  5031.     src_address = D0_INDEX + (opcode & 0x0007);
  5032.     src = register_value[src_address];
  5033.     dest_address = D0_INDEX + ((opcode & 0x0e00) >> 9);
  5034.     dest = register_value[dest_address];
  5035.     if(trace)
  5036.     {
  5037.       mnemonic += register_data[src_address].name;
  5038.       mnemonic += ",";
  5039.       mnemonic += register_data[dest_address].name;
  5040.     }
  5041.   }
  5042.  
  5043.   if(register_value[SR_INDEX] & X_FLAG)
  5044.     result = dest - src - 1;
  5045.   else
  5046.     result = dest - src;
  5047.  
  5048.   if(size == BYTE)
  5049.     result = result & 0xff;
  5050.   else if(size == WORD)
  5051.     result = result & 0xffff;
  5052.   else if(size == LONG)
  5053.     result = result & 0xffffffff;
  5054.  
  5055.   SetConditionCodes(src, dest, result, size,
  5056.                     SUBTRACTION, C_FLAG|V_FLAG|N_FLAG|X_FLAG);
  5057.   if(result)
  5058.     register_value[SR_INDEX] &= ~Z_FLAG;
  5059.  
  5060.   if(opcode & 8)
  5061.   {
  5062.     if((status = Poke(dest_address, result, size)) != EXECUTE_OK)
  5063.       return(status);
  5064.   }
  5065.   else
  5066.   {
  5067.     SetRegister(dest_address, result, size);
  5068.   }
  5069.  
  5070.   if(trace)
  5071.   {
  5072.     mnemonic += "}} ";
  5073.     trace_record += mnemonic;
  5074.   }
  5075.   return(EXECUTE_OK);
  5076. }
  5077.  
  5078. ///////////////////////////////////////////////////////////////////////////////
  5079. // Execute the 'SWAP' instruction 
  5080. ///////////////////////////////////////////////////////////////////////////////
  5081. int m68000::ExecuteSWAP(int opcode, String& trace_record, int trace)
  5082. {
  5083.   int register_number;
  5084.   unsigned int data;
  5085.  
  5086.   register_number=D0_INDEX+(opcode&7);
  5087.   data = register_value[register_number];
  5088.   data = ((data >> 16) & 0xffff) | ((data << 16) & 0xffff0000);
  5089.   SetRegister(register_number, data, LONG);
  5090.   SetConditionCodes(0, 0, data, LONG,
  5091.                     OTHER, C_FLAG|V_FLAG|Z_FLAG|N_FLAG);
  5092.   if(trace)
  5093.   {
  5094.     trace_record+="{Mnemonic {SWAP.W ";
  5095.     trace_record+=register_data[register_number].name;
  5096.     trace_record+="}} ";
  5097.   }
  5098.   return(EXECUTE_OK);
  5099. }
  5100.  
  5101. ///////////////////////////////////////////////////////////////////////////////
  5102. // Execute the 'Scc' instruction 
  5103. ///////////////////////////////////////////////////////////////////////////////
  5104. int m68000::ExecuteScc(int opcode, String& trace_record, int trace)
  5105. {
  5106.   int status, in_register_flag;
  5107.   unsigned long address;
  5108.   unsigned int result;
  5109.   String mnemonic, ea_description;
  5110.  
  5111.   if(trace) trace_record+="{Mnemonic {S";
  5112.  
  5113.   // Get the effective address
  5114.   if((status=ComputeEffectiveAddress(address, in_register_flag, ea_description,
  5115.                     opcode & 0x3f, BYTE, trace)) != EXECUTE_OK)
  5116.   { return(status); }
  5117.  
  5118.   // Check to see if the result should be all 1's or 0's
  5119.   if(CheckConditionCodes((opcode & 0x0f00) >> 8, mnemonic, trace))
  5120.     result=0xff;
  5121.   else
  5122.     result=0;
  5123.  
  5124.   // Store the result  
  5125.   if(in_register_flag)
  5126.     SetRegister(address, result, BYTE);
  5127.   else
  5128.     if((status=Poke(address, result, BYTE)) != EXECUTE_OK)
  5129.       return(status);
  5130.  
  5131.   if(trace)
  5132.   {
  5133.     mnemonic+=".B ";
  5134.     mnemonic+=ea_description;
  5135.     mnemonic+="}} ";
  5136.     trace_record+=mnemonic;
  5137.   }
  5138.   return(EXECUTE_OK);
  5139. }
  5140.  
  5141. ///////////////////////////////////////////////////////////////////////////////
  5142. // Execute the 'TAS' instruction 
  5143. ///////////////////////////////////////////////////////////////////////////////
  5144. int m68000::ExecuteTAS(int opcode, String& trace_record, int trace)
  5145. {
  5146.   int status, in_register_flag;
  5147.   unsigned long address;
  5148.   unsigned int data;
  5149.   String ea_description;
  5150.  
  5151.   // Get the effective address
  5152.   if((status=ComputeEffectiveAddress(address, in_register_flag, ea_description,
  5153.                     opcode & 0x3f, BYTE, trace)) != EXECUTE_OK)
  5154.   { return(status); }
  5155.  
  5156.   // Fetch the data
  5157.   if(in_register_flag)
  5158.     data=register_value[address];
  5159.   else
  5160.     if((status=Peek(address, data, BYTE)) != EXECUTE_OK)
  5161.       return(status);
  5162.  
  5163.   SetConditionCodes(0, 0, data, BYTE, OTHER, C_FLAG|V_FLAG|Z_FLAG|N_FLAG);
  5164.  
  5165.   // Set the high order bit
  5166.   data |= 0x80;
  5167.  
  5168.   // Store the result  
  5169.   if(in_register_flag)
  5170.     SetRegister(address, data, BYTE);
  5171.   else
  5172.     if((status=Poke(address, data, BYTE)) != EXECUTE_OK)
  5173.       return(status);
  5174.  
  5175.   if(trace)
  5176.   {
  5177.     trace_record+="{Mnemonic {TAS.B ";
  5178.     trace_record+=ea_description;
  5179.     trace_record+="}} ";
  5180.   }
  5181.   return(EXECUTE_OK);
  5182. }
  5183.  
  5184. ///////////////////////////////////////////////////////////////////////////////
  5185. // Execute the 'TRAP' instruction
  5186. ///////////////////////////////////////////////////////////////////////////////
  5187. int m68000::ExecuteTRAP(int opcode, String& trace_record, int trace)
  5188. {
  5189.   int status;
  5190.  
  5191.   // Process the exception
  5192.   if((status=ProcessException(32+(opcode&0xf))) != EXECUTE_OK)
  5193.     return(status);
  5194.  
  5195.   if(trace)
  5196.   {
  5197.     trace_record+="{Mnemonic {TRAP #$";
  5198.     trace_record+=IntToString(32+(opcode&0xf), 1);
  5199.     trace_record+="}} ";
  5200.   } 
  5201.   return(EXECUTE_OK);
  5202. }
  5203.  
  5204. ///////////////////////////////////////////////////////////////////////////////
  5205. // Execute the 'TRAPV' instruction 
  5206. ///////////////////////////////////////////////////////////////////////////////
  5207. int m68000::ExecuteTRAPV(int opcode, String& trace_record, int trace)
  5208. {
  5209.   int status;
  5210.  
  5211.   // If the overflow bit is set then trap
  5212.   if(register_value[SR_INDEX] & V_FLAG)
  5213.   {
  5214.     // Process the exception
  5215.     if((status=ProcessException(7)) != EXECUTE_OK)
  5216.       return(status);
  5217.   }
  5218.  
  5219.   if(trace)
  5220.     trace_record+="{Mnemonic {TRAPV}} ";
  5221.  
  5222.   return(EXECUTE_OK);
  5223. }
  5224.  
  5225. ///////////////////////////////////////////////////////////////////////////////
  5226. // Execute the 'TST' instruction 
  5227. ///////////////////////////////////////////////////////////////////////////////
  5228. int m68000::ExecuteTST(int opcode, String& trace_record, int trace)
  5229. {
  5230.   int status, size, in_register_flag;
  5231.   unsigned long address;
  5232.   unsigned int data;
  5233.   String ea_description;
  5234.  
  5235.   size=((opcode&0x00c0) >> 6);
  5236.  
  5237.   // Get the effective address
  5238.   if((status=ComputeEffectiveAddress(address, in_register_flag, ea_description,
  5239.                     opcode & 0x3f, size, trace)) != EXECUTE_OK)
  5240.   { return(status); }
  5241.  
  5242.   // Fetch the data
  5243.   if(in_register_flag)
  5244.     data=register_value[address];
  5245.   else
  5246.     if((status=Peek(address, data, size)) != EXECUTE_OK)
  5247.       return(status);
  5248.  
  5249.   SetConditionCodes(0, 0, data, size, OTHER, C_FLAG|V_FLAG|Z_FLAG|N_FLAG);
  5250.  
  5251.   if(trace)
  5252.   {
  5253.     trace_record+="{Mnemonic {TST";
  5254.     if(size==BYTE)
  5255.       trace_record+=".B ";
  5256.     else if(size==WORD)
  5257.       trace_record+=".W ";
  5258.     else if(size==LONG)
  5259.       trace_record+=".L ";
  5260.     trace_record+=ea_description;
  5261.     trace_record+="}} ";
  5262.   }
  5263.   return(EXECUTE_OK);
  5264. }
  5265.  
  5266. ///////////////////////////////////////////////////////////////////////////////
  5267. // Execute the 'UNLK' instruction 
  5268. ///////////////////////////////////////////////////////////////////////////////
  5269. int m68000::ExecuteUNLK(int opcode, String& trace_record, int trace)
  5270. {
  5271.   int status, register_number, stack_index;
  5272.   unsigned int fp;
  5273.  
  5274.   // Get the address register number
  5275.   register_number=A0_INDEX+(opcode&0x0007);
  5276.  
  5277.   // Adjust register_number if it's A7 and we're in supervisor mode
  5278.   if((register_number == USP_INDEX) && (register_value[SR_INDEX] & S_FLAG))
  5279.     register_number = SSP_INDEX;
  5280.  
  5281.   // Get the stack index
  5282.   if(register_value[SR_INDEX]&S_FLAG)
  5283.     stack_index=SSP_INDEX;
  5284.   else
  5285.     stack_index=USP_INDEX;
  5286.  
  5287.   // Set the stack pointer to the frame pointer
  5288.   SetRegister(stack_index, register_value[register_number], LONG);
  5289.  
  5290.   // Pop the frame pointer from the stack
  5291.   if((status=Peek(register_value[stack_index], fp , LONG)) != EXECUTE_OK)
  5292.     { return(status); }
  5293.   SetRegister(register_number, fp, LONG);
  5294.   SetRegister(stack_index, register_value[stack_index]+4, LONG);
  5295.  
  5296.   if(trace)
  5297.   {
  5298.     trace_record+="{Mnemonic {UNLK ";
  5299.     trace_record+=register_data[register_number].name;
  5300.     trace_record+="}} ";
  5301.   }
  5302.   return(EXECUTE_OK);
  5303. }
  5304.  
  5305. ///////////////////////////////////////////////////////////////////////////////
  5306. // Execute 'Invalid' instructions 
  5307. ///////////////////////////////////////////////////////////////////////////////
  5308. int m68000::ExecuteInvalid(int opcode, String& trace_record, int trace)
  5309. {
  5310.   int status;
  5311.  
  5312.   // Move the PC back to the start of the illegal instruction opcode
  5313.   SetRegister(PC_INDEX, register_value[PC_INDEX]-2, LONG);
  5314.  
  5315.   // Process the illegal instruction exception
  5316.   if((status=ProcessException(4)) != EXECUTE_OK)
  5317.     return(status);
  5318.  
  5319.   if(trace)
  5320.     trace_record+="{Mnemonic {Illegal Instruction Exception}} ";
  5321.  
  5322.   return(EXECUTE_OK);
  5323. }
  5324.  
  5325. ///////////////////////////////////////////////////////////////////////////////
  5326. // Process an Exeception
  5327. ///////////////////////////////////////////////////////////////////////////////
  5328. int m68000::ProcessException(int vector)
  5329. {
  5330.   int status;
  5331.  
  5332.   // Copy the SR to a temp
  5333.   unsigned long sr = register_value[SR_INDEX];
  5334.  
  5335.   // Change to Supervisor mode and clear the Trace mode
  5336.   register_value[SR_INDEX] |= S_FLAG;
  5337.   register_value[SR_INDEX] &= ~T_FLAG;
  5338.  
  5339.   // Push the PC and SR onto the supervisor stack
  5340.   SetRegister(SSP_INDEX, register_value[SSP_INDEX]-4, LONG);
  5341.   if((status=Poke(register_value[SSP_INDEX],
  5342.        register_value[PC_INDEX], LONG)) != EXECUTE_OK)
  5343.   { return(status); }
  5344.  
  5345.   SetRegister(SSP_INDEX, register_value[SSP_INDEX]-2, LONG);
  5346.   if((status=Poke(register_value[SSP_INDEX], sr, WORD)) != EXECUTE_OK)
  5347.   { return(status); }
  5348.  
  5349.   // Get the service routine's address
  5350.   unsigned int service_address;
  5351.   if((status=Peek(vector*4, service_address , LONG)) != EXECUTE_OK)
  5352.     return(status); 
  5353.  
  5354.   // Change the program counter to the service routine's address
  5355.   SetRegister(PC_INDEX, service_address, LONG);
  5356.  
  5357.   return(EXECUTE_OK);
  5358. }
  5359.  
  5360. ///////////////////////////////////////////////////////////////////////////////
  5361. // Execute the Address Error Cycle
  5362. ///////////////////////////////////////////////////////////////////////////////
  5363. int m68000::ExecuteAddressError(int opcode, String& trace_record, int trace)
  5364. {
  5365.   int status;
  5366.  
  5367.   // Copy the SR to a temp
  5368.   unsigned long sr = register_value[SR_INDEX];
  5369.  
  5370.   // Change to Supervisor mode and clear the Trace mode
  5371.   register_value[SR_INDEX] |= S_FLAG;
  5372.   register_value[SR_INDEX] &= ~T_FLAG;
  5373.  
  5374.   // Push the PC
  5375.   SetRegister(SSP_INDEX, register_value[SSP_INDEX]-4, LONG);
  5376.   if((status=Poke(register_value[SSP_INDEX],
  5377.        register_value[PC_INDEX], LONG)) != EXECUTE_OK)
  5378.   { return(status); }
  5379.  
  5380.   // Push the SR (tmp)
  5381.   SetRegister(SSP_INDEX, register_value[SSP_INDEX]-2, LONG);
  5382.   if((status=Poke(register_value[SSP_INDEX], sr, WORD)) != EXECUTE_OK)
  5383.   { return(status); }
  5384.  
  5385.   // Push the Opcode Word of instruction in Error
  5386.   SetRegister(SSP_INDEX, register_value[SSP_INDEX]-2, LONG);
  5387.   if((status=Poke(register_value[SSP_INDEX], opcode, WORD)) != EXECUTE_OK)
  5388.   { return(status); }
  5389.  
  5390.   ////////////////////////////////////////////////////////////////////////
  5391.   // NOTE: The following two values are not correct!!! The correct values
  5392.   //       could be derived by adding a few variables to the CPU, but
  5393.   //       I don't have time to do it now :-)
  5394.   ////////////////////////////////////////////////////////////////////////
  5395.  
  5396.   // Push Memory Address at the Fault
  5397.   SetRegister(SSP_INDEX, register_value[SSP_INDEX]-4, LONG);
  5398.   if((status=Poke(register_value[SSP_INDEX], 0, LONG)) != EXECUTE_OK)
  5399.   { return(status); }
  5400.  
  5401.   // Push status information word
  5402.   SetRegister(SSP_INDEX, register_value[SSP_INDEX]-2, LONG);
  5403.   if((status=Poke(register_value[SSP_INDEX], 9, WORD)) != EXECUTE_OK)
  5404.   { return(status); }
  5405.  
  5406.  
  5407.   // Get the service routine's address
  5408.   unsigned int service_address;
  5409.   if((status=Peek(0x0c, service_address, LONG)) != EXECUTE_OK)
  5410.     return(status); 
  5411.  
  5412.   // Change the program counter to the service routine's address
  5413.   SetRegister(PC_INDEX, service_address, LONG);
  5414.  
  5415.   if(trace)
  5416.     trace_record+="{Mnemonic {Address Error Exception}} ";
  5417.  
  5418.   return(EXECUTE_OK);
  5419. }
  5420.  
  5421. ///////////////////////////////////////////////////////////////////////////////
  5422. // Execute the Bus Error Cycle
  5423. ///////////////////////////////////////////////////////////////////////////////
  5424. int m68000::ExecuteBusError(int opcode, String& trace_record, int trace)
  5425. {
  5426.   int status;
  5427.  
  5428.   // Copy the SR to a temp
  5429.   unsigned long sr = register_value[SR_INDEX];
  5430.  
  5431.   // Change to Supervisor mode and clear the Trace mode
  5432.   register_value[SR_INDEX] |= S_FLAG;
  5433.   register_value[SR_INDEX] &= ~T_FLAG;
  5434.  
  5435.   // Push the PC
  5436.   SetRegister(SSP_INDEX, register_value[SSP_INDEX]-4, LONG);
  5437.   if((status=Poke(register_value[SSP_INDEX],
  5438.        register_value[PC_INDEX], LONG)) != EXECUTE_OK)
  5439.   { return(status); }
  5440.  
  5441.   // Push the SR (tmp)
  5442.   SetRegister(SSP_INDEX, register_value[SSP_INDEX]-2, LONG);
  5443.   if((status=Poke(register_value[SSP_INDEX], sr, WORD)) != EXECUTE_OK)
  5444.   { return(status); }
  5445.  
  5446.   // Push the Opcode Word of instruction in Error
  5447.   SetRegister(SSP_INDEX, register_value[SSP_INDEX]-2, LONG);
  5448.   if((status=Poke(register_value[SSP_INDEX], opcode, WORD)) != EXECUTE_OK)
  5449.   { return(status); }
  5450.  
  5451.   ////////////////////////////////////////////////////////////////////////
  5452.   // NOTE: The following two values are not correct!!! The correct values
  5453.   //       could be derived by adding a few variables to the CPU, but
  5454.   //       I don't have time to do it now :-)
  5455.   ////////////////////////////////////////////////////////////////////////
  5456.  
  5457.   // Push Memory Address at the Fault
  5458.   SetRegister(SSP_INDEX, register_value[SSP_INDEX]-4, LONG);
  5459.   if((status=Poke(register_value[SSP_INDEX], 0, LONG)) != EXECUTE_OK)
  5460.   { return(status); }
  5461.  
  5462.   // Push status information word
  5463.   SetRegister(SSP_INDEX, register_value[SSP_INDEX]-2, LONG);
  5464.   if((status=Poke(register_value[SSP_INDEX], 9, WORD)) != EXECUTE_OK)
  5465.   { return(status); }
  5466.  
  5467.  
  5468.   // Get the service routine's address
  5469.   unsigned int service_address;
  5470.   if((status=Peek(0x08, service_address, LONG)) != EXECUTE_OK)
  5471.     return(status); 
  5472.  
  5473.   // Change the program counter to the service routine's address
  5474.   SetRegister(PC_INDEX, service_address, LONG);
  5475.  
  5476.   if(trace)
  5477.     trace_record+="{Mnemonic {Bus Error Exception}} ";
  5478.  
  5479.   return(EXECUTE_OK);
  5480. }
  5481.  
  5482.